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

    '''

    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(uatype_UInt32.pack(self.SpecifiedAttributes))

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

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

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return NodeAttributes(data)

    def _binary_init(self, data):

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

        self.DisplayName = LocalizedText.from_binary(data)

        self.Description = LocalizedText.from_binary(data)

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

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

    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__

    __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

    '''

    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(uatype_UInt32.pack(self.MonitoredItemId))

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

        packet.append(uatype_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 = uatype_UInt32.unpack(data.read(4))[0]

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

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

        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__

    __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

    '''

    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(uatype_UInt32.pack(self.ClientHandle))

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

        packet.append(extensionobject_to_binary(self.Filter))

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return MonitoringParameters(data)

    def _binary_init(self, data):

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

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

        self.Filter = extensionobject_from_binary(data)

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

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

    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__

    __repr__ = __str__

class DeleteReferencesItem(FrozenClass):

    '''

    A request to delete a node from the server address space.

    :ivar SourceNodeId:

    :vartype SourceNodeId: NodeId

    :ivar ReferenceTypeId:

    :vartype ReferenceTypeId: NodeId

    :ivar IsForward:

    :vartype IsForward: Boolean

    :ivar TargetNodeId:

    :vartype TargetNodeId: ExpandedNodeId

    :ivar DeleteBidirectional:

    :vartype DeleteBidirectional: Boolean

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SourceNodeId = NodeId()

        self.ReferenceTypeId = NodeId()

        self.IsForward = True

        self.TargetNodeId = ExpandedNodeId()

        self.DeleteBidirectional = True

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.SourceNodeId.to_binary())

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

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

        packet.append(self.TargetNodeId.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteReferencesItem(data)

    def _binary_init(self, data):

        self.SourceNodeId = NodeId.from_binary(data)

        self.ReferenceTypeId = NodeId.from_binary(data)

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

        self.TargetNodeId = ExpandedNodeId.from_binary(data)

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

    def __str__(self):

        return 'DeleteReferencesItem(' + 'SourceNodeId:' + str(self.SourceNodeId) + ', ' + \

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

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

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

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

    __repr__ = __str__