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

    '''

        'SourceTimestamp': ('Encoding', 2),

        'ServerTimestamp': ('Encoding', 3),

        'SourcePicoseconds': ('Encoding', 4),

        'ServerPicoseconds': ('Encoding', 5),

    }

    ua_types = (

            ('Encoding', 'Byte'), 

            ('Value', 'Variant'), 

            ('StatusCode', 'StatusCode'), 

            ('SourceTimestamp', 'DateTime'),

            ('SourcePicoseconds', 'UInt16'), 

            ('ServerTimestamp', 'DateTime'), 

            ('ServerPicoseconds', 'UInt16'), 

            )

    def __init__(self, variant=None, status=None):

        self.Encoding = 0

        if not isinstance(variant, Variant):

            variant = Variant(variant)

        self.Value = variant

        if status is None:

            self.StatusCode = StatusCode()

        else:

            self.StatusCode = status

        self.SourceTimestamp = None  # DateTime()

        self.SourcePicoseconds = None

        self.ServerTimestamp = None  # DateTime()

        self.ServerPicoseconds = None

        self._freeze = True

    def __str__(self):

        s = 'DataValue(Value:{0}'.format(self.Value)

        if self.StatusCode is not None:

            s += ', StatusCode:{0}'.format(self.StatusCode)

        if self.SourceTimestamp is not None:

            s += ', SourceTimestamp:{0}'.format(self.SourceTimestamp)

        if self.ServerTimestamp is not None:

            s += ', ServerTimestamp:{0}'.format(self.ServerTimestamp)

        if self.SourcePicoseconds is not None:

            s += ', SourcePicoseconds:{0}'.format(self.SourcePicoseconds)

        if self.ServerPicoseconds is not None:

            s += ', ServerPicoseconds:{0}'.format(self.ServerPicoseconds)

        s += ')'

        return s

    __repr__ = __str__

def datatype_to_varianttype(int_type):

    """

    Takes a NodeId or int and return a VariantType

    This is only supported if int_type < 63 due to VariantType encoding

    At low level we do not have access to address space thus decoding is limited

    a better version of this method can be find in ua_utils.py

    """

    if isinstance(int_type, NodeId):

        int_type = int_type.Identifier

    if int_type <= 25:

        return VariantType(int_type)

    else:

        return VariantTypeCustom(int_type)

def get_default_value(vtype):

    """