FreeOpcUa / python-opcua

    __repr__ = __str__

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

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

        packet.append(uabin.Primitives.Double.pack(self.ProcessingInterval))

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

        for fieldname in self.AggregateType:

            packet.append(fieldname.to_binary())

        packet.append(self.AggregateConfiguration.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ReadProcessedDetails(data)

    def _binary_init(self, data):

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

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

        self.ProcessingInterval = uabin.Primitives.Double.unpack(data)

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(NodeId.from_binary(data))

        self.AggregateType = array

        self.AggregateConfiguration = AggregateConfiguration.from_binary(data)

    def __str__(self):

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

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

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

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

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

    __repr__ = __str__

class ReadAtTimeDetails(FrozenClass):

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

        for fieldname in self.NodeTypes:

            packet.append(fieldname.to_binary())

        packet.append(self.Filter.to_binary())

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return QueryFirstParameters(data)

    def _binary_init(self, data):

        self.View = ViewDescription.from_binary(data)

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(NodeTypeDescription.from_binary(data))

        self.NodeTypes = array

        self.Filter = ContentFilter.from_binary(data)

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

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

    def __str__(self):

        return 'QueryFirstParameters(' + 'View:' + str(self.View) + ', ' + \

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

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

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

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

    __repr__ = __str__

class QueryFirstRequest(FrozenClass):