FreeOpcUa / python-opcua

    __repr__ = __str__

class AggregateConfiguration(FrozenClass):

    '''

    :ivar UseServerCapabilitiesDefaults:

    :vartype UseServerCapabilitiesDefaults: Boolean

    :ivar TreatUncertainAsBad:

    :vartype TreatUncertainAsBad: Boolean

    :ivar PercentDataBad:

    :vartype PercentDataBad: Byte

    :ivar PercentDataGood:

    :vartype PercentDataGood: Byte

    :ivar UseSlopedExtrapolation:

    :vartype UseSlopedExtrapolation: Boolean

    '''

    ua_types = {

        'UseServerCapabilitiesDefaults': 'Boolean',

        'TreatUncertainAsBad': 'Boolean',

        'PercentDataBad': 'Byte',

        'PercentDataGood': 'Byte',

        'UseSlopedExtrapolation': 'Boolean',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

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

    __repr__ = __str__

class ReadRawModifiedDetails(FrozenClass):

    '''

    :ivar IsReadModified:

    :vartype IsReadModified: Boolean

    :ivar StartTime:

    :vartype StartTime: DateTime

    :ivar EndTime:

    :vartype EndTime: DateTime

    :ivar NumValuesPerNode:

    :vartype NumValuesPerNode: UInt32

    :ivar ReturnBounds:

    :vartype ReturnBounds: Boolean

    '''

    ua_types = {

        'IsReadModified': 'Boolean',

        'StartTime': 'DateTime',

        'EndTime': 'DateTime',

        'NumValuesPerNode': 'UInt32',

        'ReturnBounds': 'Boolean',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

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