FreeOpcUa / python-opcua

        self.TypeId = FourByteNodeId(ObjectIds.AddReferencesRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = AddReferencesParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        packet.append(self.Parameters.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return AddReferencesRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = AddReferencesParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class AddReferencesResponse(FrozenClass):

    '''

    Adds one or more references to the server address space.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: StatusCode

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = (

        ('TypeId', 'NodeId'),

        ('ResponseHeader', 'ResponseHeader'),

        ('Results', 'ListOfStatusCode'),

        ('DiagnosticInfos', 'ListOfDiagnosticInfo'),

               )

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.AddReferencesResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

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

        for fieldname in self.Results:

            packet.append(fieldname.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ActivateSessionResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        self.Parameters = ActivateSessionResult.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class CloseSessionRequest(FrozenClass):

    '''

    Closes a session with the server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar DeleteSubscriptions:

    :vartype DeleteSubscriptions: Boolean

    '''

    ua_types = (

        ('TypeId', 'NodeId'),

        ('RequestHeader', 'RequestHeader'),

        ('DeleteSubscriptions', 'Boolean'),

               )

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.CloseSessionRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.DeleteSubscriptions = True

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return CloseSessionRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

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

    def __str__(self):

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

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

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

    __repr__ = __str__

        self.RelativePath = RelativePath.from_binary(data)

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

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

    def __str__(self):

        return 'QueryDataDescription(' + 'RelativePath:' + str(self.RelativePath) + ', ' + \

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

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

    __repr__ = __str__

class NodeTypeDescription(FrozenClass):

    '''

    :ivar TypeDefinitionNode:

    :vartype TypeDefinitionNode: ExpandedNodeId

    :ivar IncludeSubTypes:

    :vartype IncludeSubTypes: Boolean

    :ivar DataToReturn:

    :vartype DataToReturn: QueryDataDescription

    '''

    ua_types = (

        ('TypeDefinitionNode', 'ExpandedNodeId'),

        ('IncludeSubTypes', 'Boolean'),

        ('DataToReturn', 'ListOfQueryDataDescription'),

               )

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeDefinitionNode = ExpandedNodeId()

        self.IncludeSubTypes = True

        self.DataToReturn = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.TypeDefinitionNode.to_binary())

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

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

        for fieldname in self.DataToReturn:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return NodeTypeDescription(data)

    def _binary_init(self, data):

        self.TypeDefinitionNode = ExpandedNodeId.from_binary(data)

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

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(QueryDataDescription.from_binary(data))

        self.DataToReturn = array

    def __str__(self):

        return 'NodeTypeDescription(' + 'TypeDefinitionNode:' + str(self.TypeDefinitionNode) + ', ' + \

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

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

    __repr__ = __str__