FreeOpcUa / python-opcua

    __repr__ = __str__

class AddNodesRequest(FrozenClass):

    '''

    Adds one or more nodes to the server address space.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: AddNodesParameters

    '''

    ua_types = [

        ('TypeId', 'NodeId'),

        ('RequestHeader', 'RequestHeader'),

        ('Parameters', 'AddNodesParameters'),

               ]

    def __init__(self):

        self.TypeId = FourByteNodeId(ObjectIds.AddNodesRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = AddNodesParameters()

        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):

        obj = AddNodesRequest()

        obj.TypeId = NodeId.from_binary(data)

        obj.RequestHeader = RequestHeader.from_binary(data)

        obj.Parameters = AddNodesParameters.from_binary(data)

        return obj

    def __str__(self):

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

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

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

    __repr__ = __str__

class AddNodesResponse(FrozenClass):

    '''

    Adds one or more nodes to the server address space.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: AddNodesResult

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = [

        ('TypeId', 'NodeId'),

        ('ResponseHeader', 'ResponseHeader'),

        ('Results', 'ListOfAddNodesResult'),

        ('DiagnosticInfos', 'ListOfDiagnosticInfo'),

               ]

    def __init__(self):

        self.TypeId = FourByteNodeId(ObjectIds.AddNodesResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        self._freeze = True

    def to_binary(self):

        obj.Value = Variant.from_binary(data)

        obj.DataType = NodeId.from_binary(data)

        self.ValueRank = uabin.Primitives.Int32.unpack(data)

        obj.ArrayDimensions = uabin.Primitives.UInt32.unpack_array(data)

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

        return obj

    def __str__(self):

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

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

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

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

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

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

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

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

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

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

    __repr__ = __str__

class ReferenceTypeAttributes(FrozenClass):

    '''

    The attributes for a reference type node.

    :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

    :ivar IsAbstract:

    :vartype IsAbstract: Boolean

    :ivar Symmetric:

    :vartype Symmetric: Boolean

    :ivar InverseName:

    :vartype InverseName: LocalizedText

    '''

    ua_types = [

        ('SpecifiedAttributes', 'UInt32'),

        ('DisplayName', 'LocalizedText'),

        ('Description', 'LocalizedText'),

        ('WriteMask', 'UInt32'),

        ('UserWriteMask', 'UInt32'),

        ('IsAbstract', 'Boolean'),

        ('Symmetric', 'Boolean'),

        ('InverseName', 'LocalizedText'),

               ]

    def __init__(self):

        self.SpecifiedAttributes = 0

        self.DisplayName = LocalizedText()

        self.Description = LocalizedText()

        self.WriteMask = 0

        self.UserWriteMask = 0

        self.IsAbstract = True

        self.Symmetric = True

        self.InverseName = LocalizedText()

        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))

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

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

        packet.append(self.InverseName.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):