FreeOpcUa / python-opcua

    __repr__ = __str__

class Argument(FrozenClass):

    '''

    An argument for a method.

    :ivar Name:

    :vartype Name: String

    :ivar DataType:

    :vartype DataType: NodeId

    :ivar ValueRank:

    :vartype ValueRank: Int32

    :ivar ArrayDimensions:

    :vartype ArrayDimensions: UInt32

    :ivar Description:

    :vartype Description: LocalizedText

    '''

    ua_types = [

        ('Name', 'String'),

        ('DataType', 'NodeId'),

        ('ValueRank', 'Int32'),

        ('ArrayDimensions', 'ListOfUInt32'),

        ('Description', 'LocalizedText'),

               ]

    def __init__(self):

        self.Name = None

        self.DataType = NodeId()

        self.ValueRank = 0

        self.ArrayDimensions = []

        self.Description = LocalizedText()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.String.pack(self.Name))

        packet.append(self.DataType.to_binary())

        packet.append(uabin.Primitives.Int32.pack(self.ValueRank))

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

        for fieldname in self.ArrayDimensions:

            packet.append(uabin.Primitives.UInt32.pack(fieldname))

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        obj = Argument()

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

        obj.DataType = NodeId.from_binary(data)

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

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

        obj.Description = LocalizedText.from_binary(data)

        return obj

    def __str__(self):

        return 'Argument(' + 'Name:' + str(self.Name) + ', ' + \

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

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

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

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

    __repr__ = __str__

class EnumValueType(FrozenClass):

    __repr__ = __str__

class AxisInformation(FrozenClass):

    '''

    :ivar EngineeringUnits:

    :vartype EngineeringUnits: EUInformation

    :ivar EURange:

    :vartype EURange: Range

    :ivar Title:

    :vartype Title: LocalizedText

    :ivar AxisScaleType:

    :vartype AxisScaleType: AxisScaleEnumeration

    :ivar AxisSteps:

    :vartype AxisSteps: Double

    '''

    ua_types = [

        ('EngineeringUnits', 'EUInformation'),

        ('EURange', 'Range'),

        ('Title', 'LocalizedText'),

        ('AxisScaleType', 'AxisScaleEnumeration'),

        ('AxisSteps', 'ListOfDouble'),

               ]

    def __init__(self):

        self.EngineeringUnits = EUInformation()

        self.EURange = Range()

        self.Title = LocalizedText()

        self.AxisScaleType = AxisScaleEnumeration(0)

        self.AxisSteps = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.EngineeringUnits.to_binary())

        packet.append(self.EURange.to_binary())

        packet.append(self.Title.to_binary())

        packet.append(uabin.Primitives.UInt32.pack(self.AxisScaleType.value))

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

        for fieldname in self.AxisSteps:

            packet.append(uabin.Primitives.Double.pack(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        obj = AxisInformation()

        obj.EngineeringUnits = EUInformation.from_binary(data)

        obj.EURange = Range.from_binary(data)

        obj.Title = LocalizedText.from_binary(data)

        self.AxisScaleType = AxisScaleEnumeration(uabin.Primitives.UInt32.unpack(data))

        obj.AxisSteps = uabin.Primitives.Double.unpack_array(data)

        return obj

    def __str__(self):

        return 'AxisInformation(' + 'EngineeringUnits:' + str(self.EngineeringUnits) + ', ' + \

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

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

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

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

    __repr__ = __str__

class XVType(FrozenClass):

    __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

    '''

    ua_types = [

        ('SpecifiedAttributes', 'UInt32'),

        ('DisplayName', 'LocalizedText'),

        ('Description', 'LocalizedText'),

        ('WriteMask', 'UInt32'),

        ('UserWriteMask', 'UInt32'),

               ]

    def __init__(self):

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        obj = NodeAttributes()

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

        obj.DisplayName = LocalizedText.from_binary(data)

        obj.Description = LocalizedText.from_binary(data)

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

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

        return obj

    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__

class ObjectAttributes(FrozenClass):

    __repr__ = __str__

class AttributeOperand(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar Alias:

    :vartype Alias: String

    :ivar BrowsePath:

    :vartype BrowsePath: RelativePath

    :ivar AttributeId:

    :vartype AttributeId: UInt32

    :ivar IndexRange:

    :vartype IndexRange: String

    '''

    ua_types = [

        ('NodeId', 'NodeId'),

        ('Alias', 'String'),

        ('BrowsePath', 'RelativePath'),

        ('AttributeId', 'UInt32'),

        ('IndexRange', 'String'),

               ]

    def __init__(self):

        self.NodeId = NodeId()

        self.Alias = None

        self.BrowsePath = RelativePath()

        self.AttributeId = 0

        self.IndexRange = None

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(uabin.Primitives.String.pack(self.Alias))

        packet.append(self.BrowsePath.to_binary())

        packet.append(uabin.Primitives.UInt32.pack(self.AttributeId))

        packet.append(uabin.Primitives.String.pack(self.IndexRange))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        obj = AttributeOperand()

        obj.NodeId = NodeId.from_binary(data)

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

        obj.BrowsePath = RelativePath.from_binary(data)

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

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

        return obj

    def __str__(self):

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

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

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

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

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

    __repr__ = __str__

class SimpleAttributeOperand(FrozenClass):