FreeOpcUa / python-opcua

class ActivateSessionParameters(FrozenClass):

    '''

    :ivar ClientSignature:

    :vartype ClientSignature: SignatureData

    :ivar ClientSoftwareCertificates:

    :vartype ClientSoftwareCertificates: SignedSoftwareCertificate

    :ivar LocaleIds:

    :vartype LocaleIds: String

    :ivar UserIdentityToken:

    :vartype UserIdentityToken: ExtensionObject

    :ivar UserTokenSignature:

    :vartype UserTokenSignature: SignatureData

    '''

    ua_types = {

        'ClientSignature': 'SignatureData',

        'ClientSoftwareCertificates': 'SignedSoftwareCertificate',

        'LocaleIds': 'String',

        'UserIdentityToken': 'ExtensionObject',

        'UserTokenSignature': 'SignatureData',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ClientSignature = SignatureData()

        self.ClientSoftwareCertificates = []

        self.LocaleIds = []

        self.UserIdentityToken = None

        self.UserTokenSignature = SignatureData()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.ClientSignature.to_binary())

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

        for fieldname in self.ClientSoftwareCertificates:

            packet.append(fieldname.to_binary())

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

        for fieldname in self.LocaleIds:

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

        packet.append(extensionobject_to_binary(self.UserIdentityToken))

        packet.append(self.UserTokenSignature.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ActivateSessionParameters(data)

    def _binary_init(self, data):

        self.ClientSignature = SignatureData.from_binary(data)

        length = uabin.Primitives.Int32.unpack(data)

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(SignedSoftwareCertificate.from_binary(data))

        self.ClientSoftwareCertificates = array

        self.LocaleIds = uabin.Primitives.String.unpack_array(data)

        self.UserIdentityToken = extensionobject_from_binary(data)

        self.UserTokenSignature = SignatureData.from_binary(data)

    def __str__(self):

        return 'ActivateSessionParameters(' + 'ClientSignature:' + str(self.ClientSignature) + ', ' + \

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

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

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

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

    __repr__ = __str__

class ActivateSessionRequest(FrozenClass):

    '''

    Activates a session with the server.

        packet = []

        packet.append(self.StatusCode.to_binary())

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

        for fieldname in self.DataStatusCodes:

            packet.append(fieldname.to_binary())

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

        for fieldname in self.DataDiagnosticInfos:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ParsingResult(data)

    def _binary_init(self, data):

        self.StatusCode = StatusCode.from_binary(data)

        length = uabin.Primitives.Int32.unpack(data)

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(StatusCode.from_binary(data))

        self.DataStatusCodes = array

        length = uabin.Primitives.Int32.unpack(data)

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(DiagnosticInfo.from_binary(data))

        self.DataDiagnosticInfos = array

    def __str__(self):

        return 'ParsingResult(' + 'StatusCode:' + str(self.StatusCode) + ', ' + \

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

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

    __repr__ = __str__

class QueryFirstParameters(FrozenClass):

    '''

    :ivar View:

    :vartype View: ViewDescription

    :ivar NodeTypes:

    :vartype NodeTypes: NodeTypeDescription

    :ivar Filter:

    :vartype Filter: ContentFilter

    :ivar MaxDataSetsToReturn:

    :vartype MaxDataSetsToReturn: UInt32

    :ivar MaxReferencesToReturn:

    :vartype MaxReferencesToReturn: UInt32

    '''

    ua_types = {

        'View': 'ViewDescription',

        'NodeTypes': 'NodeTypeDescription',

        'Filter': 'ContentFilter',

        'MaxDataSetsToReturn': 'UInt32',

        'MaxReferencesToReturn': 'UInt32',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.View = ViewDescription()

        self.NodeTypes = []

        self.Filter = ContentFilter()

        self.MaxDataSetsToReturn = 0

        self.MaxReferencesToReturn = 0

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.View.to_binary())

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

        self.IsReadModified = True

        self.StartTime = datetime.utcnow()

        self.EndTime = datetime.utcnow()

        self.NumValuesPerNode = 0

        self.ReturnBounds = True

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(uabin.Primitives.DateTime.pack(self.StartTime))

        packet.append(uabin.Primitives.DateTime.pack(self.EndTime))

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ReadRawModifiedDetails(data)

    def _binary_init(self, data):

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

        self.StartTime = uabin.Primitives.DateTime.unpack(data)

        self.EndTime = uabin.Primitives.DateTime.unpack(data)

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

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

    def __str__(self):

        return 'ReadRawModifiedDetails(' + 'IsReadModified:' + str(self.IsReadModified) + ', ' + \

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

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

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

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

    __repr__ = __str__

class ReadProcessedDetails(FrozenClass):

    '''

    :ivar StartTime:

    :vartype StartTime: DateTime

    :ivar EndTime:

    :vartype EndTime: DateTime

    :ivar ProcessingInterval:

    :vartype ProcessingInterval: Double

    :ivar AggregateType:

    :vartype AggregateType: NodeId

    :ivar AggregateConfiguration:

    :vartype AggregateConfiguration: AggregateConfiguration

    '''

    ua_types = {

        'StartTime': 'DateTime',

        'EndTime': 'DateTime',

        'ProcessingInterval': 'Double',

        'AggregateType': 'NodeId',

        'AggregateConfiguration': 'AggregateConfiguration',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.StartTime = datetime.utcnow()

        self.EndTime = datetime.utcnow()

        self.ProcessingInterval = 0

        self.AggregateType = []

        self.AggregateConfiguration = AggregateConfiguration()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.DateTime.pack(self.StartTime))

        packet.append(uabin.Primitives.DateTime.pack(self.EndTime))