FreeOpcUa / python-opcua

    __repr__ = __str__

class ResponseHeader(FrozenClass):

    '''

    The header passed with every server response.

    :ivar Timestamp:

    :vartype Timestamp: DateTime

    :ivar RequestHandle:

    :vartype RequestHandle: UInt32

    :ivar ServiceResult:

    :vartype ServiceResult: StatusCode

    :ivar ServiceDiagnostics:

    :vartype ServiceDiagnostics: DiagnosticInfo

    :ivar StringTable:

    :vartype StringTable: String

    :ivar AdditionalHeader:

    :vartype AdditionalHeader: ExtensionObject

    '''

    ua_types = [

        ('Timestamp', 'DateTime'),

        ('RequestHandle', 'UInt32'),

        ('ServiceResult', 'StatusCode'),

        ('ServiceDiagnostics', 'DiagnosticInfo'),

        ('StringTable', 'ListOfString'),

        ('AdditionalHeader', 'ExtensionObject'),

               ]

    def __init__(self):

        self.Timestamp = datetime.utcnow()

        self.RequestHandle = 0

        self.ServiceResult = StatusCode()

        self.ServiceDiagnostics = DiagnosticInfo()

        self.StringTable = []

        self.AdditionalHeader = ExtensionObject()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.DateTime.pack(self.Timestamp))

        packet.append(uabin.Primitives.UInt32.pack(self.RequestHandle))

        packet.append(self.ServiceResult.to_binary())

        packet.append(self.ServiceDiagnostics.to_binary())

        packet.append(uabin.Primitives.Int32.pack(len(self.StringTable)))

        for fieldname in self.StringTable:

            packet.append(uabin.Primitives.String.pack(fieldname))

        packet.append(uabin.extensionobject_to_binary(self.AdditionalHeader))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        obj = ResponseHeader()

        self.Timestamp = uabin.Primitives.DateTime.unpack(data)

        self.RequestHandle = uabin.Primitives.UInt32.unpack(data)

        obj.ServiceResult = StatusCode.from_binary(data)

        obj.ServiceDiagnostics = DiagnosticInfo.from_binary(data)

        obj.StringTable = uabin.Primitives.String.unpack_array(data)

        obj.AdditionalHeader = uabin.extensionobject_from_binary(data)

        return obj

    def __str__(self):

        return 'ResponseHeader(' + 'Timestamp:' + str(self.Timestamp) + ', ' + \

               'RequestHandle:' + str(self.RequestHandle) + ', ' + \

               'ServiceResult:' + str(self.ServiceResult) + ', ' + \

               'ServiceDiagnostics:' + str(self.ServiceDiagnostics) + ', ' + \

               'StringTable:' + str(self.StringTable) + ', ' + \

               'AdditionalHeader:' + str(self.AdditionalHeader) + ')'

    __repr__ = __str__

class ServiceFault(FrozenClass):

    __repr__ = __str__

class ReadProcessedDetails(FrozenClass):

    '''

    :ivar StartTime:

    :vartype StartTime: DateTime

    :ivar EndTime:

    :vartype EndTime: DateTime

    :ivar ProcessingInterval:

    :vartype ProcessingInterval: Double

    :ivar AggregateType:

    :vartype AggregateType: NodeId

    :ivar AggregateConfiguration:

    :vartype AggregateConfiguration: AggregateConfiguration

    '''

    ua_types = [

        ('StartTime', 'DateTime'),

        ('EndTime', 'DateTime'),

        ('ProcessingInterval', 'Double'),

        ('AggregateType', 'ListOfNodeId'),

        ('AggregateConfiguration', 'AggregateConfiguration'),

               ]

    def __init__(self):

        self.StartTime = datetime.utcnow()

        self.EndTime = datetime.utcnow()

        self.ProcessingInterval = 0

        self.AggregateType = []

        self.AggregateConfiguration = AggregateConfiguration()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.DateTime.pack(self.StartTime))

        packet.append(uabin.Primitives.DateTime.pack(self.EndTime))

        packet.append(uabin.Primitives.Double.pack(self.ProcessingInterval))

        packet.append(uabin.Primitives.Int32.pack(len(self.AggregateType)))

        for fieldname in self.AggregateType:

            packet.append(fieldname.to_binary())

        packet.append(self.AggregateConfiguration.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        obj = ReadProcessedDetails()

        self.StartTime = uabin.Primitives.DateTime.unpack(data)

        self.EndTime = uabin.Primitives.DateTime.unpack(data)

        self.ProcessingInterval = uabin.Primitives.Double.unpack(data)

        length = uabin.Primitives.Int32.unpack(data)

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(NodeId.from_binary(data))

        obj.AggregateType = array

        obj.AggregateConfiguration = AggregateConfiguration.from_binary(data)

        return obj

    def __str__(self):

        return 'ReadProcessedDetails(' + 'StartTime:' + str(self.StartTime) + ', ' + \

               'EndTime:' + str(self.EndTime) + ', ' + \

               'ProcessingInterval:' + str(self.ProcessingInterval) + ', ' + \

               'AggregateType:' + str(self.AggregateType) + ', ' + \

               'AggregateConfiguration:' + str(self.AggregateConfiguration) + ')'

    __repr__ = __str__

class ReadAtTimeDetails(FrozenClass):