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', 'ListOfSignedSoftwareCertificate'),

        ('LocaleIds', 'ListOfString'),

        ('UserIdentityToken', 'ExtensionObject'),

        ('UserTokenSignature', 'SignatureData'),

               ]

    def __init__(self):

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

        obj = ActivateSessionParameters()

        obj.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))

        obj.ClientSoftwareCertificates = array

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

        obj.UserIdentityToken = extensionobject_from_binary(data)

        obj.UserTokenSignature = SignatureData.from_binary(data)

        return obj

    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', 'ListOfNodeId'),

        ('AggregateConfiguration', 'AggregateConfiguration'),

               ]

    def __init__(self):

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

        obj = ReadProcessedDetails()

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

        obj.AggregateType = array

        obj.AggregateConfiguration = AggregateConfiguration.from_binary(data)

        return obj

    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', 'ListOfNodeTypeDescription'),

        ('Filter', 'ContentFilter'),

        ('MaxDataSetsToReturn', 'UInt32'),

        ('MaxReferencesToReturn', 'UInt32'),

               ]

    def __init__(self):

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

        obj = QueryFirstParameters()

        obj.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))

        obj.NodeTypes = array

        obj.Filter = ContentFilter.from_binary(data)

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

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

        return obj

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