FreeOpcUa / python-opcua

    __repr__ = __str__

class TransferResult(FrozenClass):

    '''

    :ivar StatusCode:

    :vartype StatusCode: StatusCode

    :ivar AvailableSequenceNumbers:

    :vartype AvailableSequenceNumbers: UInt32

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.StatusCode = StatusCode()

        self.AvailableSequenceNumbers = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        for fieldname in self.AvailableSequenceNumbers:

            packet.append(uatype_UInt32.pack(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return TransferResult(data)

    def _binary_init(self, data):

        self.StatusCode = StatusCode.from_binary(data)

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

    def __str__(self):

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

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

    __repr__ = __str__

    __repr__ = __str__

class DeleteEventDetails(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar EventIds:

    :vartype EventIds: ByteString

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodeId = NodeId()

        self.EventIds = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        for fieldname in self.EventIds:

            packet.append(pack_bytes(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteEventDetails(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

        self.EventIds = unpack_uatype_array('ByteString', data)

    def __str__(self):

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

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

    __repr__ = __str__

    __repr__ = __str__

class DeleteAtTimeDetails(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar ReqTimes:

    :vartype ReqTimes: DateTime

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodeId = NodeId()

        self.ReqTimes = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        for fieldname in self.ReqTimes:

            packet.append(pack_datetime(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteAtTimeDetails(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

        self.ReqTimes = unpack_uatype_array('DateTime', data)

    def __str__(self):

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

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

    __repr__ = __str__

    __repr__ = __str__

class UnregisterNodesResponse(FrozenClass):

    '''

    Unregisters one or more previously registered nodes.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.UnregisterNodesResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.TypeId.to_binary())

        packet.append(self.ResponseHeader.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return UnregisterNodesResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

    def __str__(self):

        return 'UnregisterNodesResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

    __repr__ = __str__

    __repr__ = __str__

class BrowsePathTarget(FrozenClass):

    '''

    The target of the translated path.

    :ivar TargetId:

    :vartype TargetId: ExpandedNodeId

    :ivar RemainingPathIndex:

    :vartype RemainingPathIndex: UInt32

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TargetId = ExpandedNodeId()

        self.RemainingPathIndex = 0

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.TargetId.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return BrowsePathTarget(data)

    def _binary_init(self, data):

        self.TargetId = ExpandedNodeId.from_binary(data)

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

    def __str__(self):

        return 'BrowsePathTarget(' + 'TargetId:' + str(self.TargetId) + ', ' + \

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

    __repr__ = __str__

    __repr__ = __str__

class BrowsePath(FrozenClass):

    '''

    A request to translate a path into a node id.

    :ivar StartingNode:

    :vartype StartingNode: NodeId

    :ivar RelativePath:

    :vartype RelativePath: RelativePath

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.StartingNode = NodeId()

        self.RelativePath = RelativePath()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.StartingNode.to_binary())

        packet.append(self.RelativePath.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return BrowsePath(data)

    def _binary_init(self, data):

        self.StartingNode = NodeId.from_binary(data)

        self.RelativePath = RelativePath.from_binary(data)

    def __str__(self):

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

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

    __repr__ = __str__

    __repr__ = __str__

class DeleteNodesItem(FrozenClass):

    '''

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

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar DeleteTargetReferences:

    :vartype DeleteTargetReferences: Boolean

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodeId = NodeId()

        self.DeleteTargetReferences = True

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteNodesItem(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

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

    def __str__(self):

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

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

    __repr__ = __str__

    __repr__ = __str__

class AddNodesResult(FrozenClass):

    '''

    A result of an add node operation.

    :ivar StatusCode:

    :vartype StatusCode: StatusCode

    :ivar AddedNodeId:

    :vartype AddedNodeId: NodeId

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.StatusCode = StatusCode()

        self.AddedNodeId = NodeId()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.AddedNodeId.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return AddNodesResult(data)

    def _binary_init(self, data):

        self.StatusCode = StatusCode.from_binary(data)

        self.AddedNodeId = NodeId.from_binary(data)

    def __str__(self):

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

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

    __repr__ = __str__

    __repr__ = __str__

class CloseSessionResponse(FrozenClass):

    '''

    Closes a session with the server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.CloseSessionResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.TypeId.to_binary())

        packet.append(self.ResponseHeader.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return CloseSessionResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

    def __str__(self):

        return 'CloseSessionResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

    __repr__ = __str__

    __repr__ = __str__

class CloseSecureChannelResponse(FrozenClass):

    '''

    Closes a secure channel.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.CloseSecureChannelResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.TypeId.to_binary())

        packet.append(self.ResponseHeader.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return CloseSecureChannelResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

    def __str__(self):

        return 'CloseSecureChannelResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

    __repr__ = __str__

    __repr__ = __str__

class CloseSecureChannelRequest(FrozenClass):

    '''

    Closes a secure channel.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.CloseSecureChannelRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.TypeId.to_binary())

        packet.append(self.RequestHeader.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return CloseSecureChannelRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

    def __str__(self):

        return 'CloseSecureChannelRequest(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

    __repr__ = __str__

    __repr__ = __str__

class RegisterServerResponse(FrozenClass):

    '''

    Registers a server with the discovery server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.RegisterServerResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.TypeId.to_binary())

        packet.append(self.ResponseHeader.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return RegisterServerResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

    def __str__(self):

        return 'RegisterServerResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

    __repr__ = __str__

    __repr__ = __str__

class ServiceFault(FrozenClass):

    '''

    The response returned by all services when there is a service level error.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.ServiceFault_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.TypeId.to_binary())

        packet.append(self.ResponseHeader.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ServiceFault(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

    def __str__(self):

        return 'ServiceFault(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

    __repr__ = __str__

    __repr__ = __str__

class SemanticChangeStructureDataType(FrozenClass):

    '''

    :ivar Affected:

    :vartype Affected: NodeId

    :ivar AffectedType:

    :vartype AffectedType: NodeId

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Affected = NodeId()

        self.AffectedType = NodeId()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.Affected.to_binary())

        packet.append(self.AffectedType.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return SemanticChangeStructureDataType(data)

    def _binary_init(self, data):

        self.Affected = NodeId.from_binary(data)

        self.AffectedType = NodeId.from_binary(data)

    def __str__(self):

        return 'SemanticChangeStructureDataType(' + 'Affected:' + str(self.Affected) + ', ' + \

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

    __repr__ = __str__

    __repr__ = __str__

class StatusResult(FrozenClass):

    '''

    :ivar StatusCode:

    :vartype StatusCode: StatusCode

    :ivar DiagnosticInfo:

    :vartype DiagnosticInfo: DiagnosticInfo

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.StatusCode = StatusCode()

        self.DiagnosticInfo = DiagnosticInfo()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.DiagnosticInfo.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return StatusResult(data)

    def _binary_init(self, data):

        self.StatusCode = StatusCode.from_binary(data)

        self.DiagnosticInfo = DiagnosticInfo.from_binary(data)

    def __str__(self):

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

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

    __repr__ = __str__

    __repr__ = __str__

class StatusChangeNotification(FrozenClass):

    '''

    :ivar Status:

    :vartype Status: StatusCode

    :ivar DiagnosticInfo:

    :vartype DiagnosticInfo: DiagnosticInfo

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Status = StatusCode()

        self.DiagnosticInfo = DiagnosticInfo()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.Status.to_binary())

        packet.append(self.DiagnosticInfo.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return StatusChangeNotification(data)

    def _binary_init(self, data):

        self.Status = StatusCode.from_binary(data)

        self.DiagnosticInfo = DiagnosticInfo.from_binary(data)

    def __str__(self):

        return 'StatusChangeNotification(' + 'Status:' + str(self.Status) + ', ' + \

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

    __repr__ = __str__

    __repr__ = __str__

class MonitoredItemNotification(FrozenClass):

    '''

    :ivar ClientHandle:

    :vartype ClientHandle: UInt32

    :ivar Value:

    :vartype Value: DataValue

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ClientHandle = 0

        self.Value = DataValue()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.Value.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return MonitoredItemNotification(data)

    def _binary_init(self, data):

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

        self.Value = DataValue.from_binary(data)

    def __str__(self):

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

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

    __repr__ = __str__

    __repr__ = __str__

class MonitoredItemModifyRequest(FrozenClass):

    '''

    :ivar MonitoredItemId:

    :vartype MonitoredItemId: UInt32

    :ivar RequestedParameters:

    :vartype RequestedParameters: MonitoringParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.MonitoredItemId = 0

        self.RequestedParameters = MonitoringParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestedParameters.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return MonitoredItemModifyRequest(data)

    def _binary_init(self, data):

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

        self.RequestedParameters = MonitoringParameters.from_binary(data)

    def __str__(self):

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

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

    __repr__ = __str__

    __repr__ = __str__

class HistoryReadResult(FrozenClass):

    '''

    :ivar StatusCode:

    :vartype StatusCode: StatusCode

    :ivar ContinuationPoint:

    :vartype ContinuationPoint: ByteString

    :ivar HistoryData:

    :vartype HistoryData: ExtensionObject

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.StatusCode = StatusCode()

        self.ContinuationPoint = None

        self.HistoryData = None

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(pack_bytes(self.ContinuationPoint))

        packet.append(extensionobject_to_binary(self.HistoryData))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return HistoryReadResult(data)

    def _binary_init(self, data):

        self.StatusCode = StatusCode.from_binary(data)

        self.ContinuationPoint = unpack_bytes(data)

        self.HistoryData = extensionobject_from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__