FreeOpcUa / python-opcua

    __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

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.StartTime = datetime.now()

        self.EndTime = datetime.now()

        self.ProcessingInterval = 0

        self.AggregateType = []

        self.AggregateConfiguration = AggregateConfiguration()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(pack_datetime(self.StartTime))

        packet.append(pack_datetime(self.EndTime))

        packet.append(uatype_Double.pack(self.ProcessingInterval))

        packet.append(uatype_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):

        return ReadProcessedDetails(data)

    def _binary_init(self, data):

        self.StartTime = unpack_datetime(data)

        self.EndTime = unpack_datetime(data)

        self.ProcessingInterval = uatype_Double.unpack(data.read(8))[0]

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(NodeId.from_binary(data))

        self.AggregateType = array

        self.AggregateConfiguration = AggregateConfiguration.from_binary(data)

    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):

    __repr__ = __str__

class QueryFirstParameters(FrozenClass):

    '''

    :ivar View:

    :vartype View: ViewDescription

    :ivar NodeTypes:

    :vartype NodeTypes: NodeTypeDescription

    :ivar Filter:

    :vartype Filter: ContentFilter

    :ivar MaxDataSetsToReturn:

    :vartype MaxDataSetsToReturn: UInt32

    :ivar MaxReferencesToReturn:

    :vartype MaxReferencesToReturn: UInt32

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.View = ViewDescription()

        self.NodeTypes = []

        self.Filter = ContentFilter()

        self.MaxDataSetsToReturn = 0

        self.MaxReferencesToReturn = 0

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.View.to_binary())

        packet.append(uatype_Int32.pack(len(self.NodeTypes)))

        for fieldname in self.NodeTypes:

            packet.append(fieldname.to_binary())

        packet.append(self.Filter.to_binary())

        packet.append(uatype_UInt32.pack(self.MaxDataSetsToReturn))

        packet.append(uatype_UInt32.pack(self.MaxReferencesToReturn))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return QueryFirstParameters(data)

    def _binary_init(self, data):

        self.View = ViewDescription.from_binary(data)

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(NodeTypeDescription.from_binary(data))

        self.NodeTypes = array

        self.Filter = ContentFilter.from_binary(data)

        self.MaxDataSetsToReturn = uatype_UInt32.unpack(data.read(4))[0]

        self.MaxReferencesToReturn = uatype_UInt32.unpack(data.read(4))[0]

    def __str__(self):

        return 'QueryFirstParameters(' + 'View:' + str(self.View) + ', ' + \

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

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

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

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

    __repr__ = __str__

class QueryFirstRequest(FrozenClass):

    __repr__ = __str__

class UpdateEventDetails(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar PerformInsertReplace:

    :vartype PerformInsertReplace: PerformUpdateType

    :ivar Filter:

    :vartype Filter: EventFilter

    :ivar EventData:

    :vartype EventData: HistoryEventFieldList

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodeId = NodeId()

        self.PerformInsertReplace = PerformUpdateType(0)

        self.Filter = EventFilter()

        self.EventData = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.NodeId.to_binary())

        packet.append(uatype_UInt32.pack(self.PerformInsertReplace.value))

        packet.append(self.Filter.to_binary())

        packet.append(uatype_Int32.pack(len(self.EventData)))

        for fieldname in self.EventData:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return UpdateEventDetails(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

        self.PerformInsertReplace = PerformUpdateType(uatype_UInt32.unpack(data.read(4))[0])

        self.Filter = EventFilter.from_binary(data)

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(HistoryEventFieldList.from_binary(data))

        self.EventData = array

    def __str__(self):

        return 'UpdateEventDetails(' + 'NodeId:' + str(self.NodeId) + ', ' + \

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

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

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

    __repr__ = __str__

class DeleteRawModifiedDetails(FrozenClass):

    __repr__ = __str__

class HistoryReadParameters(FrozenClass):

    '''

    :ivar HistoryReadDetails:

    :vartype HistoryReadDetails: ExtensionObject

    :ivar TimestampsToReturn:

    :vartype TimestampsToReturn: TimestampsToReturn

    :ivar ReleaseContinuationPoints:

    :vartype ReleaseContinuationPoints: Boolean

    :ivar NodesToRead:

    :vartype NodesToRead: HistoryReadValueId

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.HistoryReadDetails = None

        self.TimestampsToReturn = TimestampsToReturn(0)

        self.ReleaseContinuationPoints = True

        self.NodesToRead = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(extensionobject_to_binary(self.HistoryReadDetails))

        packet.append(uatype_UInt32.pack(self.TimestampsToReturn.value))

        packet.append(uatype_Boolean.pack(self.ReleaseContinuationPoints))

        packet.append(uatype_Int32.pack(len(self.NodesToRead)))

        for fieldname in self.NodesToRead:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return HistoryReadParameters(data)

    def _binary_init(self, data):

        self.HistoryReadDetails = extensionobject_from_binary(data)

        self.TimestampsToReturn = TimestampsToReturn(uatype_UInt32.unpack(data.read(4))[0])

        self.ReleaseContinuationPoints = uatype_Boolean.unpack(data.read(1))[0]

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(HistoryReadValueId.from_binary(data))

        self.NodesToRead = array

    def __str__(self):

        return 'HistoryReadParameters(' + 'HistoryReadDetails:' + str(self.HistoryReadDetails) + ', ' + \

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

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

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

    __repr__ = __str__

class HistoryReadRequest(FrozenClass):

    __repr__ = __str__

class NodeReference(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar ReferenceTypeId:

    :vartype ReferenceTypeId: NodeId

    :ivar IsForward:

    :vartype IsForward: Boolean

    :ivar ReferencedNodeIds:

    :vartype ReferencedNodeIds: NodeId

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodeId = NodeId()

        self.ReferenceTypeId = NodeId()

        self.IsForward = True

        self.ReferencedNodeIds = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.NodeId.to_binary())

        packet.append(self.ReferenceTypeId.to_binary())

        packet.append(uatype_Boolean.pack(self.IsForward))

        packet.append(uatype_Int32.pack(len(self.ReferencedNodeIds)))

        for fieldname in self.ReferencedNodeIds:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return NodeReference(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

        self.ReferenceTypeId = NodeId.from_binary(data)

        self.IsForward = uatype_Boolean.unpack(data.read(1))[0]

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(NodeId.from_binary(data))

        self.ReferencedNodeIds = array

    def __str__(self):

        return 'NodeReference(' + 'NodeId:' + str(self.NodeId) + ', ' + \

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

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

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

    __repr__ = __str__

class ContentFilterElement(FrozenClass):