FreeOpcUa / python-opcua

    __repr__ = __str__

class RelativePath(FrozenClass):

    '''

    A relative path constructed from reference types and browse names.

    :ivar Elements:

    :vartype Elements: RelativePathElement

    '''

    ua_types = {

        '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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

        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 PublishParameters(FrozenClass):

    '''

    :ivar SubscriptionAcknowledgements:

    :vartype SubscriptionAcknowledgements: SubscriptionAcknowledgement

    '''

    ua_types = {

        '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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

        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

    '''

    ua_types = {

        '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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

        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

    '''

    ua_types = {

        '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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

        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

    '''

    ua_types = {

        '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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

        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

    '''

    ua_types = {

        '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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

        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

    '''

    ua_types = {

        '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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

        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

    '''

    ua_types = {

        '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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

        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

    '''

    ua_types = {

        '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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

        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

    '''

    ua_types = {

        '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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

        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

    '''

    ua_types = {

        '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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

        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

    '''

    ua_types = {

        '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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

        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

    '''

    ua_types = {

        '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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

        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

    '''

    ua_types = {

        '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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

        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

    '''

    ua_types = {

        '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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

        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

    '''

    ua_types = {

        '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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

        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 AddReferencesParameters(FrozenClass):

    '''

    :ivar ReferencesToAdd:

    :vartype ReferencesToAdd: AddReferencesItem

    '''

    ua_types = {

        'ReferencesToAdd': 'AddReferencesItem',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ReferencesToAdd = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.ReferencesToAdd:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return AddReferencesParameters(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(AddReferencesItem.from_binary(data))

        self.ReferencesToAdd = array

    def __str__(self):

        return 'AddReferencesParameters(' + 'ReferencesToAdd:' + str(self.ReferencesToAdd) + ')'

    __repr__ = __str__

class AddReferencesRequest(FrozenClass):

    __repr__ = __str__

class AddNodesParameters(FrozenClass):

    '''

    :ivar NodesToAdd:

    :vartype NodesToAdd: AddNodesItem

    '''

    ua_types = {

        '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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

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