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

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Name = None

        self.DataType = NodeId()

        self.ValueRank = 0

        self.ArrayDimensions = []

        self.Description = LocalizedText()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(pack_string(self.Name))

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

        packet.append(uatype_Int32.pack(self.ValueRank))

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

        for fieldname in self.ArrayDimensions:

            packet.append(uatype_UInt32.pack(fieldname))

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return Argument(data)

    def _binary_init(self, data):

        self.Name = unpack_string(data)

        self.DataType = NodeId.from_binary(data)

        self.ValueRank = uatype_Int32.unpack(data.read(4))[0]

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

        self.Description = LocalizedText.from_binary(data)

    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

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        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(uatype_UInt32.pack(self.AxisScaleType.value))

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

        for fieldname in self.AxisSteps:

            packet.append(uatype_Double.pack(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return AxisInformation(data)

    def _binary_init(self, data):

        self.EngineeringUnits = EUInformation.from_binary(data)

        self.EURange = Range.from_binary(data)

        self.Title = LocalizedText.from_binary(data)

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

        self.AxisSteps = unpack_uatype_array('Double', data)

    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__

    __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

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

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

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

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

        packet.append(pack_string(self.IndexRange))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return AttributeOperand(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

        self.Alias = unpack_string(data)

        self.BrowsePath = RelativePath.from_binary(data)

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

        self.IndexRange = unpack_string(data)

    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__