FreeOpcUa / python-opcua

class AttributeWriteMask(IntEnum):

    '''

    Define bits used to indicate which attributes are writable.

    :ivar None_:

    :vartype None_: 0

    :ivar AccessLevel:

    :vartype AccessLevel: 1

    :ivar ArrayDimensions:

    :vartype ArrayDimensions: 2

    :ivar BrowseName:

    :vartype BrowseName: 4

    :ivar ContainsNoLoops:

    :vartype ContainsNoLoops: 8

    :ivar DataType:

    :vartype DataType: 16

    :ivar Description:

    :vartype Description: 32

    :ivar DisplayName:

    :vartype DisplayName: 64

    :ivar EventNotifier:

    :vartype EventNotifier: 128

    :ivar Executable:

    :vartype Executable: 256

    :ivar Historizing:

    :vartype Historizing: 512

    :ivar InverseName:

    :vartype InverseName: 1024

    :ivar IsAbstract:

    :vartype IsAbstract: 2048

    :ivar MinimumSamplingInterval:

    :vartype MinimumSamplingInterval: 4096

    :ivar NodeClass:

    :vartype NodeClass: 8192

    :ivar NodeId:

    :vartype NodeId: 16384

    :ivar Symmetric:

    :vartype Symmetric: 32768

    :ivar UserAccessLevel:

    :vartype UserAccessLevel: 65536

    :ivar UserExecutable:

    :vartype UserExecutable: 131072

    :ivar UserWriteMask:

    :vartype UserWriteMask: 262144

    :ivar ValueRank:

    :vartype ValueRank: 524288

    :ivar WriteMask:

    :vartype WriteMask: 1048576

    :ivar ValueForVariableType:

    :vartype ValueForVariableType: 2097152

    '''

    None_ = 0

    AccessLevel = 1

    ArrayDimensions = 2

    BrowseName = 4

    ContainsNoLoops = 8

    DataType = 16

    Description = 32

    DisplayName = 64

    EventNotifier = 128

    Executable = 256

    Historizing = 512

    InverseName = 1024

    IsAbstract = 2048

    MinimumSamplingInterval = 4096

    NodeClass = 8192

    NodeId = 16384

    Symmetric = 32768

    UserAccessLevel = 65536

    UserExecutable = 131072

    UserWriteMask = 262144

    ValueRank = 524288

    WriteMask = 1048576

    ValueForVariableType = 2097152

class BrowseDirection(IntEnum):

    '''

            return VariantType.String

        elif isinstance(val, bytes):

            return VariantType.ByteString

        elif isinstance(val, datetime):

            return VariantType.DateTime

        elif isinstance(val, uuid.UUID):

            return VariantType.Guid

        else:

            if isinstance(val, object):

                try:

                    return getattr(VariantType, val.__class__.__name__)

                except AttributeError:

                    return VariantType.ExtensionObject

            else:

                raise UaError("Could not guess UA type of {0} with type {1}, specify UA type".format(val, type(val)))

    def __str__(self):

        return "Variant(val:{0!s},type:{1})".format(self.Value, self.VariantType)

    __repr__ = __str__

    def to_binary(self):

        b = []

        encoding = self.VariantType.value & 0b111111

        if self.is_array or type(self.Value) in (list, tuple):

            self.is_array = True

            encoding = uabin.set_bit(encoding, 7)

            if self.Dimensions is not None:

                encoding = uabin.set_bit(encoding, 6)

            b.append(uabin.Primitives.UInt8.pack(encoding))

            b.append(uabin.pack_uatype_array(self.VariantType, flatten(self.Value)))

            if self.Dimensions is not None:

                b.append(uabin.pack_uatype_array(VariantType.Int32, self.Dimensions))

        else:

            b.append(uabin.Primitives.UInt8.pack(encoding))

            b.append(uabin.pack_uatype(self.VariantType, self.Value))

        return b"".join(b)

    @staticmethod

    def from_binary(data):

        dimensions = None

        array = False

        encoding = ord(data.read(1))

        int_type = encoding & 0b00111111

        vtype = datatype_to_varianttype(int_type)

        if uabin.test_bit(encoding, 7):

            value = uabin.unpack_uatype_array(vtype, data)

            array = True

        else:

            value = uabin.unpack_uatype(vtype, data)

        if uabin.test_bit(encoding, 6):

            dimensions = uabin.unpack_uatype_array(VariantType.Int32, data)

            value = reshape(value, dimensions)

        return Variant(value, vtype, dimensions, is_array=array)

def reshape(flat, dims):

    subdims = dims[1:]

    subsize = 1

    for i in subdims:

        if i == 0:

            i = 1

        subsize *= i

    while dims[0] * subsize > len(flat):

        flat.append([])

    if not subdims or subdims == [0]:

        return flat