FreeOpcUa / python-opcua

    __repr__ = __str__

class RequestHeader(FrozenClass):

    '''

    The header passed with every server request.

    :ivar AuthenticationToken:

    :vartype AuthenticationToken: NodeId

    :ivar Timestamp:

    :vartype Timestamp: DateTime

    :ivar RequestHandle:

    :vartype RequestHandle: UInt32

    :ivar ReturnDiagnostics:

    :vartype ReturnDiagnostics: UInt32

    :ivar AuditEntryId:

    :vartype AuditEntryId: String

    :ivar TimeoutHint:

    :vartype TimeoutHint: UInt32

    :ivar AdditionalHeader:

    :vartype AdditionalHeader: ExtensionObject

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.AuthenticationToken = NodeId()

        self.Timestamp = datetime.now()

        self.RequestHandle = 0

        self.ReturnDiagnostics = 0

        self.AuditEntryId = ''

        self.TimeoutHint = 0

        self.AdditionalHeader = None

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.AuthenticationToken.to_binary())

        packet.append(pack_datetime(self.Timestamp))

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

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

        packet.append(pack_string(self.AuditEntryId))

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

        packet.append(extensionobject_to_binary(self.AdditionalHeader))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return RequestHeader(data)

    def _binary_init(self, data):

        self.AuthenticationToken = NodeId.from_binary(data)

        self.Timestamp = unpack_datetime(data)

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

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

        self.AuditEntryId = unpack_string(data)

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

        self.AdditionalHeader = extensionobject_from_binary(data)

    def __str__(self):

        return 'RequestHeader(' + 'AuthenticationToken:' + str(self.AuthenticationToken) + ', ' + \

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

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

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

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

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

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

    __repr__ = __str__

class ResponseHeader(FrozenClass):

    __repr__ = __str__

class AddReferencesItem(FrozenClass):

    '''

    A request to add a reference to the server address space.

    :ivar SourceNodeId:

    :vartype SourceNodeId: NodeId

    :ivar ReferenceTypeId:

    :vartype ReferenceTypeId: NodeId

    :ivar IsForward:

    :vartype IsForward: Boolean

    :ivar TargetServerUri:

    :vartype TargetServerUri: String

    :ivar TargetNodeId:

    :vartype TargetNodeId: ExpandedNodeId

    :ivar TargetNodeClass:

    :vartype TargetNodeClass: NodeClass

    '''

    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.TargetServerUri = ''

        self.TargetNodeId = ExpandedNodeId()

        self.TargetNodeClass = NodeClass(0)

        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(pack_string(self.TargetServerUri))

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

        packet.append(uatype_UInt32.pack(self.TargetNodeClass.value))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return AddReferencesItem(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.TargetServerUri = unpack_string(data)

        self.TargetNodeId = ExpandedNodeId.from_binary(data)

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

    def __str__(self):

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

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

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

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

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

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

    __repr__ = __str__

class AddReferencesRequest(FrozenClass):