FreeOpcUa / python-opcua

    __repr__ = __str__

class RelativePath(FrozenClass):

    '''

    A relative path constructed from reference types and browse names.

    :ivar Elements:

    :vartype Elements: RelativePathElement

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Elements = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.Elements:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return RelativePath(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(RelativePathElement.from_binary(data))

        self.Elements = array

    def __str__(self):

        return 'RelativePath(' + 'Elements:' + str(self.Elements) + ')'

    __repr__ = __str__

class BrowsePath(FrozenClass):

    __repr__ = __str__

class TransferSubscriptionsParameters(FrozenClass):

    '''

    :ivar SubscriptionIds:

    :vartype SubscriptionIds: UInt32

    :ivar SendInitialValues:

    :vartype SendInitialValues: Boolean

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SubscriptionIds = []

        self.SendInitialValues = True

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.SubscriptionIds:

            packet.append(uatype_UInt32.pack(fieldname))

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return TransferSubscriptionsParameters(data)

    def _binary_init(self, data):

        self.SubscriptionIds = unpack_uatype_array('UInt32', data)

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

    def __str__(self):

        return 'TransferSubscriptionsParameters(' + 'SubscriptionIds:' + str(self.SubscriptionIds) + ', ' + \

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

    __repr__ = __str__

class TransferSubscriptionsRequest(FrozenClass):

    __repr__ = __str__

class SetPublishingModeParameters(FrozenClass):

    '''

    :ivar PublishingEnabled:

    :vartype PublishingEnabled: Boolean

    :ivar SubscriptionIds:

    :vartype SubscriptionIds: UInt32

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.PublishingEnabled = True

        self.SubscriptionIds = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        for fieldname in self.SubscriptionIds:

            packet.append(uatype_UInt32.pack(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return SetPublishingModeParameters(data)

    def _binary_init(self, data):

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

        self.SubscriptionIds = unpack_uatype_array('UInt32', data)

    def __str__(self):

        return 'SetPublishingModeParameters(' + 'PublishingEnabled:' + str(self.PublishingEnabled) + ', ' + \

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

    __repr__ = __str__

class SetPublishingModeRequest(FrozenClass):

    __repr__ = __str__

class DeleteMonitoredItemsParameters(FrozenClass):

    '''

    :ivar SubscriptionId:

    :vartype SubscriptionId: UInt32

    :ivar MonitoredItemIds:

    :vartype MonitoredItemIds: UInt32

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SubscriptionId = 0

        self.MonitoredItemIds = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        for fieldname in self.MonitoredItemIds:

            packet.append(uatype_UInt32.pack(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteMonitoredItemsParameters(data)

    def _binary_init(self, data):

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

        self.MonitoredItemIds = unpack_uatype_array('UInt32', data)

    def __str__(self):

        return 'DeleteMonitoredItemsParameters(' + 'SubscriptionId:' + str(self.SubscriptionId) + ', ' + \

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

    __repr__ = __str__

class DeleteMonitoredItemsRequest(FrozenClass):

    __repr__ = __str__

class PublishParameters(FrozenClass):

    '''

    :ivar SubscriptionAcknowledgements:

    :vartype SubscriptionAcknowledgements: SubscriptionAcknowledgement

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SubscriptionAcknowledgements = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.SubscriptionAcknowledgements:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return PublishParameters(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(SubscriptionAcknowledgement.from_binary(data))

        self.SubscriptionAcknowledgements = array

    def __str__(self):

        return 'PublishParameters(' + 'SubscriptionAcknowledgements:' + str(self.SubscriptionAcknowledgements) + ')'

    __repr__ = __str__

class PublishRequest(FrozenClass):

    __repr__ = __str__

class HistoryEventFieldList(FrozenClass):

    '''

    :ivar EventFields:

    :vartype EventFields: Variant

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.EventFields = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.EventFields:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return HistoryEventFieldList(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(Variant.from_binary(data))

        self.EventFields = array

    def __str__(self):

        return 'HistoryEventFieldList(' + 'EventFields:' + str(self.EventFields) + ')'

    __repr__ = __str__

class StatusChangeNotification(FrozenClass):

    __repr__ = __str__

class EventNotificationList(FrozenClass):

    '''

    :ivar Events:

    :vartype Events: EventFieldList

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Events = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.Events:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return EventNotificationList(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(EventFieldList.from_binary(data))

        self.Events = array

    def __str__(self):

        return 'EventNotificationList(' + 'Events:' + str(self.Events) + ')'

    __repr__ = __str__

class EventFieldList(FrozenClass):

    __repr__ = __str__

class CallParameters(FrozenClass):

    '''

    :ivar MethodsToCall:

    :vartype MethodsToCall: CallMethodRequest

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.MethodsToCall = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.MethodsToCall:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return CallParameters(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(CallMethodRequest.from_binary(data))

        self.MethodsToCall = array

    def __str__(self):

        return 'CallParameters(' + 'MethodsToCall:' + str(self.MethodsToCall) + ')'

    __repr__ = __str__

class CallRequest(FrozenClass):

    __repr__ = __str__

class HistoryUpdateParameters(FrozenClass):

    '''

    :ivar HistoryUpdateDetails:

    :vartype HistoryUpdateDetails: ExtensionObject

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.HistoryUpdateDetails = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.HistoryUpdateDetails:

            packet.append(extensionobject_to_binary(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return HistoryUpdateParameters(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(extensionobject_from_binary(data))

        self.HistoryUpdateDetails = array

    def __str__(self):

        return 'HistoryUpdateParameters(' + 'HistoryUpdateDetails:' + str(self.HistoryUpdateDetails) + ')'

    __repr__ = __str__

class HistoryUpdateRequest(FrozenClass):

    __repr__ = __str__

class WriteParameters(FrozenClass):

    '''

    :ivar NodesToWrite:

    :vartype NodesToWrite: WriteValue

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodesToWrite = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.NodesToWrite:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return WriteParameters(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(WriteValue.from_binary(data))

        self.NodesToWrite = array

    def __str__(self):

        return 'WriteParameters(' + 'NodesToWrite:' + str(self.NodesToWrite) + ')'

    __repr__ = __str__

class WriteRequest(FrozenClass):

    __repr__ = __str__

class HistoryEvent(FrozenClass):

    '''

    :ivar Events:

    :vartype Events: HistoryEventFieldList

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Events = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.Events:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return HistoryEvent(data)

    def _binary_init(self, 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.Events = array

    def __str__(self):

        return 'HistoryEvent(' + 'Events:' + str(self.Events) + ')'

    __repr__ = __str__

class HistoryReadParameters(FrozenClass):

    __repr__ = __str__

class HistoryData(FrozenClass):

    '''

    :ivar DataValues:

    :vartype DataValues: DataValue

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.DataValues = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.DataValues:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return HistoryData(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(DataValue.from_binary(data))

        self.DataValues = array

    def __str__(self):

        return 'HistoryData(' + 'DataValues:' + str(self.DataValues) + ')'

    __repr__ = __str__

class ModificationInfo(FrozenClass):

    __repr__ = __str__

class ContentFilter(FrozenClass):

    '''

    :ivar Elements:

    :vartype Elements: ContentFilterElement

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Elements = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.Elements:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ContentFilter(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(ContentFilterElement.from_binary(data))

        self.Elements = array

    def __str__(self):

        return 'ContentFilter(' + 'Elements:' + str(self.Elements) + ')'

    __repr__ = __str__

class ElementOperand(FrozenClass):

    __repr__ = __str__

class UnregisterNodesParameters(FrozenClass):

    '''

    :ivar NodesToUnregister:

    :vartype NodesToUnregister: NodeId

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodesToUnregister = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.NodesToUnregister:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return UnregisterNodesParameters(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(NodeId.from_binary(data))

        self.NodesToUnregister = array

    def __str__(self):

        return 'UnregisterNodesParameters(' + 'NodesToUnregister:' + str(self.NodesToUnregister) + ')'

    __repr__ = __str__

class UnregisterNodesRequest(FrozenClass):

    __repr__ = __str__

class RegisterNodesResult(FrozenClass):

    '''

    :ivar RegisteredNodeIds:

    :vartype RegisteredNodeIds: NodeId

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.RegisteredNodeIds = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.RegisteredNodeIds:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return RegisterNodesResult(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(NodeId.from_binary(data))

        self.RegisteredNodeIds = array

    def __str__(self):

        return 'RegisterNodesResult(' + 'RegisteredNodeIds:' + str(self.RegisteredNodeIds) + ')'

    __repr__ = __str__

class RegisterNodesResponse(FrozenClass):

    __repr__ = __str__

class RegisterNodesParameters(FrozenClass):

    '''

    :ivar NodesToRegister:

    :vartype NodesToRegister: NodeId

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodesToRegister = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.NodesToRegister:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return RegisterNodesParameters(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(NodeId.from_binary(data))

        self.NodesToRegister = array

    def __str__(self):

        return 'RegisterNodesParameters(' + 'NodesToRegister:' + str(self.NodesToRegister) + ')'

    __repr__ = __str__

class RegisterNodesRequest(FrozenClass):

    __repr__ = __str__

class TranslateBrowsePathsToNodeIdsParameters(FrozenClass):

    '''

    :ivar BrowsePaths:

    :vartype BrowsePaths: BrowsePath

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.BrowsePaths = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.BrowsePaths:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return TranslateBrowsePathsToNodeIdsParameters(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(BrowsePath.from_binary(data))

        self.BrowsePaths = array

    def __str__(self):

        return 'TranslateBrowsePathsToNodeIdsParameters(' + 'BrowsePaths:' + str(self.BrowsePaths) + ')'

    __repr__ = __str__

class TranslateBrowsePathsToNodeIdsRequest(FrozenClass):

    __repr__ = __str__

class DeleteReferencesParameters(FrozenClass):

    '''

    :ivar ReferencesToDelete:

    :vartype ReferencesToDelete: DeleteReferencesItem

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ReferencesToDelete = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.ReferencesToDelete:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteReferencesParameters(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(DeleteReferencesItem.from_binary(data))

        self.ReferencesToDelete = array

    def __str__(self):

        return 'DeleteReferencesParameters(' + 'ReferencesToDelete:' + str(self.ReferencesToDelete) + ')'

    __repr__ = __str__

class DeleteReferencesRequest(FrozenClass):

    __repr__ = __str__

class DeleteNodesParameters(FrozenClass):

    '''

    :ivar NodesToDelete:

    :vartype NodesToDelete: DeleteNodesItem

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodesToDelete = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.NodesToDelete:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteNodesParameters(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(DeleteNodesItem.from_binary(data))

        self.NodesToDelete = array

    def __str__(self):

        return 'DeleteNodesParameters(' + 'NodesToDelete:' + str(self.NodesToDelete) + ')'

    __repr__ = __str__

class DeleteNodesRequest(FrozenClass):

    __repr__ = __str__

class AddNodesParameters(FrozenClass):

    '''

    :ivar NodesToAdd:

    :vartype NodesToAdd: AddNodesItem

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodesToAdd = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.NodesToAdd:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return AddNodesParameters(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(AddNodesItem.from_binary(data))

        self.NodesToAdd = array

    def __str__(self):

        return 'AddNodesParameters(' + 'NodesToAdd:' + str(self.NodesToAdd) + ')'

    __repr__ = __str__

class AddNodesRequest(FrozenClass):