FreeOpcUa / python-opcua

    def to_binary(self):

        packet = []

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

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

        packet.append(extensionobject_to_binary(self.Filter))

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return MonitoringParameters(data)

    def _binary_init(self, data):

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

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

        self.Filter = extensionobject_from_binary(data)

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

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

    def __str__(self):

        return 'MonitoringParameters(' + 'ClientHandle:' + str(self.ClientHandle) + ', ' + \

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

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

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

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

    __repr__ = __str__

class MonitoredItemCreateRequest(FrozenClass):

    '''

    :ivar ItemToMonitor:

    :vartype ItemToMonitor: ReadValueId

    :ivar MonitoringMode:

    :vartype MonitoringMode: MonitoringMode

    :ivar RequestedParameters:

    :vartype RequestedParameters: MonitoringParameters

    '''

    ua_types = (

        ('ItemToMonitor', 'ReadValueId'),

        ('MonitoringMode', 'MonitoringMode'),

        ('RequestedParameters', 'MonitoringParameters'),

               )

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ItemToMonitor = ReadValueId()

        self.MonitoringMode = MonitoringMode(0)

        self.RequestedParameters = MonitoringParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.ItemToMonitor.to_binary())

        packet.append(uabin.Primitives.UInt32.pack(self.MonitoringMode.value))

        self.UseServerCapabilitiesDefaults = True

        self.TreatUncertainAsBad = True

        self.PercentDataBad = 0

        self.PercentDataGood = 0

        self.UseSlopedExtrapolation = True

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        packet.append(uabin.Primitives.Byte.pack(self.PercentDataBad))

        packet.append(uabin.Primitives.Byte.pack(self.PercentDataGood))

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return AggregateConfiguration(data)

    def _binary_init(self, data):

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

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

        self.PercentDataBad = uabin.Primitives.Byte.unpack(data)

        self.PercentDataGood = uabin.Primitives.Byte.unpack(data)

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

    def __str__(self):

        return 'AggregateConfiguration(' + 'UseServerCapabilitiesDefaults:' + str(self.UseServerCapabilitiesDefaults) + ', ' + \

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

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

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

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

    __repr__ = __str__

class AggregateFilter(FrozenClass):

    '''

    :ivar StartTime:

    :vartype StartTime: DateTime

    :ivar AggregateType:

    :vartype AggregateType: NodeId

    :ivar ProcessingInterval:

    :vartype ProcessingInterval: Double

    :ivar AggregateConfiguration:

    :vartype AggregateConfiguration: AggregateConfiguration

    '''

    ua_types = (

        ('StartTime', 'DateTime'),

        ('AggregateType', 'NodeId'),

        ('ProcessingInterval', 'Double'),

        ('AggregateConfiguration', 'AggregateConfiguration'),

               )

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

        ('QueryDataSets', 'ListOfQueryDataSet'),

        ('ContinuationPoint', 'ByteString'),

        ('ParsingResults', 'ListOfParsingResult'),

        ('DiagnosticInfos', 'ListOfDiagnosticInfo'),

        ('FilterResult', 'ContentFilterResult'),

               )

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.QueryDataSets = []

        self.ContinuationPoint = None

        self.ParsingResults = []

        self.DiagnosticInfos = []

        self.FilterResult = ContentFilterResult()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.QueryDataSets:

            packet.append(fieldname.to_binary())

        packet.append(uabin.Primitives.ByteString.pack(self.ContinuationPoint))

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

        for fieldname in self.ParsingResults:

            packet.append(fieldname.to_binary())

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

        for fieldname in self.DiagnosticInfos:

            packet.append(fieldname.to_binary())

        packet.append(self.FilterResult.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return QueryFirstResult(data)

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(QueryDataSet.from_binary(data))

        self.QueryDataSets = array

        self.ContinuationPoint = uabin.Primitives.ByteString.unpack(data)

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(ParsingResult.from_binary(data))

        self.ParsingResults = array

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(DiagnosticInfo.from_binary(data))

        self.DiagnosticInfos = array

        self.FilterResult = ContentFilterResult.from_binary(data)

    def __str__(self):