FreeOpcUa / python-opcua

    __repr__ = __str__

class NodeAttributes(FrozenClass):

    '''

    The base attributes for all nodes.

    :ivar SpecifiedAttributes:

    :vartype SpecifiedAttributes: UInt32

    :ivar DisplayName:

    :vartype DisplayName: LocalizedText

    :ivar Description:

    :vartype Description: LocalizedText

    :ivar WriteMask:

    :vartype WriteMask: UInt32

    :ivar UserWriteMask:

    :vartype UserWriteMask: UInt32

    '''

    ua_types = {

        'SpecifiedAttributes': 'UInt32',

        'DisplayName': 'LocalizedText',

        'Description': 'LocalizedText',

        'WriteMask': 'UInt32',

        'UserWriteMask': 'UInt32',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SpecifiedAttributes = 0

        self.DisplayName = LocalizedText()

        self.Description = LocalizedText()

        self.WriteMask = 0

        self.UserWriteMask = 0

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.DisplayName.to_binary())

        packet.append(self.Description.to_binary())

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return NodeAttributes(data)

    def _binary_init(self, data):

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

        self.DisplayName = LocalizedText.from_binary(data)

        self.Description = LocalizedText.from_binary(data)

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

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

    def __str__(self):

        return 'NodeAttributes(' + 'SpecifiedAttributes:' + str(self.SpecifiedAttributes) + ', ' + \

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

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

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

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

    __repr__ = __str__

class ObjectAttributes(FrozenClass):

    __repr__ = __str__

class MonitoredItemCreateResult(FrozenClass):

    '''

    :ivar StatusCode:

    :vartype StatusCode: StatusCode

    :ivar MonitoredItemId:

    :vartype MonitoredItemId: UInt32

    :ivar RevisedSamplingInterval:

    :vartype RevisedSamplingInterval: Double

    :ivar RevisedQueueSize:

    :vartype RevisedQueueSize: UInt32

    :ivar FilterResult:

    :vartype FilterResult: ExtensionObject

    '''

    ua_types = {

        'StatusCode': 'StatusCode',

        'MonitoredItemId': 'UInt32',

        'RevisedSamplingInterval': 'Double',

        'RevisedQueueSize': 'UInt32',

        'FilterResult': 'ExtensionObject',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.StatusCode = StatusCode()

        self.MonitoredItemId = 0

        self.RevisedSamplingInterval = 0

        self.RevisedQueueSize = 0

        self.FilterResult = None

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.StatusCode.to_binary())

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

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

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

        packet.append(extensionobject_to_binary(self.FilterResult))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return MonitoredItemCreateResult(data)

    def _binary_init(self, data):

        self.StatusCode = StatusCode.from_binary(data)

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

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

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

        self.FilterResult = extensionobject_from_binary(data)

    def __str__(self):

        return 'MonitoredItemCreateResult(' + 'StatusCode:' + str(self.StatusCode) + ', ' + \

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

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

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

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

    __repr__ = __str__

class CreateMonitoredItemsParameters(FrozenClass):

    __repr__ = __str__

class MonitoringParameters(FrozenClass):

    '''

    :ivar ClientHandle:

    :vartype ClientHandle: UInt32

    :ivar SamplingInterval:

    :vartype SamplingInterval: Double

    :ivar Filter:

    :vartype Filter: ExtensionObject

    :ivar QueueSize:

    :vartype QueueSize: UInt32

    :ivar DiscardOldest:

    :vartype DiscardOldest: Boolean

    '''

    ua_types = {

        'ClientHandle': 'UInt32',

        'SamplingInterval': 'Double',

        'Filter': 'ExtensionObject',

        'QueueSize': 'UInt32',

        'DiscardOldest': 'Boolean',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ClientHandle = 0

        self.SamplingInterval = 0

        self.Filter = None

        self.QueueSize = 0

        self.DiscardOldest = True

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        packet.append(extensionobject_to_binary(self.Filter))

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

        packet.append(uabin.Primitives.Boolean.pack(self.DiscardOldest))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return MonitoringParameters(data)

    def _binary_init(self, data):

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

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

        self.Filter = extensionobject_from_binary(data)

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

        self.DiscardOldest = uabin.Primitives.Boolean.unpack(data)

    def __str__(self):

        return 'MonitoringParameters(' + 'ClientHandle:' + str(self.ClientHandle) + ', ' + \

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

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

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

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

    __repr__ = __str__

class MonitoredItemCreateRequest(FrozenClass):

    __repr__ = __str__

class AttributeOperand(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar Alias:

    :vartype Alias: String

    :ivar BrowsePath:

    :vartype BrowsePath: RelativePath

    :ivar AttributeId:

    :vartype AttributeId: UInt32

    :ivar IndexRange:

    :vartype IndexRange: String

    '''

    ua_types = {

        'NodeId': 'NodeId',

        'Alias': 'String',

        'BrowsePath': 'RelativePath',

        'AttributeId': 'UInt32',

        'IndexRange': 'String',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodeId = NodeId()

        self.Alias = None

        self.BrowsePath = RelativePath()

        self.AttributeId = 0

        self.IndexRange = None

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(uabin.Primitives.String.pack(self.Alias))

        packet.append(self.BrowsePath.to_binary())

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

        packet.append(uabin.Primitives.String.pack(self.IndexRange))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return AttributeOperand(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

        self.Alias = uabin.Primitives.String.unpack(data)

        self.BrowsePath = RelativePath.from_binary(data)

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

        self.IndexRange = uabin.Primitives.String.unpack(data)

    def __str__(self):

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

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

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

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

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

    __repr__ = __str__

class SimpleAttributeOperand(FrozenClass):