FreeOpcUa / python-opcua

    __repr__ = __str__

class RelativePathElement(FrozenClass):

    '''

    An element in a relative path.

    :ivar ReferenceTypeId:

    :vartype ReferenceTypeId: NodeId

    :ivar IsInverse:

    :vartype IsInverse: Boolean

    :ivar IncludeSubtypes:

    :vartype IncludeSubtypes: Boolean

    :ivar TargetName:

    :vartype TargetName: QualifiedName

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ReferenceTypeId = NodeId()

        self.IsInverse = True

        self.IncludeSubtypes = True

        self.TargetName = QualifiedName()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.ReferenceTypeId.to_binary())

        packet.append(uatype_Boolean.pack(self.IsInverse))

        packet.append(uatype_Boolean.pack(self.IncludeSubtypes))

        packet.append(self.TargetName.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return RelativePathElement(data)

    def _binary_init(self, data):

        self.ReferenceTypeId = NodeId.from_binary(data)

        self.IsInverse = uatype_Boolean.unpack(data.read(1))[0]

        self.IncludeSubtypes = uatype_Boolean.unpack(data.read(1))[0]

        self.TargetName = QualifiedName.from_binary(data)

    def __str__(self):

        return 'RelativePathElement(' + 'ReferenceTypeId:' + str(self.ReferenceTypeId) + ', ' + \

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

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

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

    __repr__ = __str__

class RelativePath(FrozenClass):

    __repr__ = __str__

class MonitoredItemModifyResult(FrozenClass):

    '''

    :ivar StatusCode:

    :vartype StatusCode: StatusCode

    :ivar RevisedSamplingInterval:

    :vartype RevisedSamplingInterval: Double

    :ivar RevisedQueueSize:

    :vartype RevisedQueueSize: UInt32

    :ivar FilterResult:

    :vartype FilterResult: ExtensionObject

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.StatusCode = StatusCode()

        self.RevisedSamplingInterval = 0

        self.RevisedQueueSize = 0

        self.FilterResult = None

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(uatype_Double.pack(self.RevisedSamplingInterval))

        packet.append(uatype_UInt32.pack(self.RevisedQueueSize))

        packet.append(extensionobject_to_binary(self.FilterResult))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return MonitoredItemModifyResult(data)

    def _binary_init(self, data):

        self.StatusCode = StatusCode.from_binary(data)

        self.RevisedSamplingInterval = uatype_Double.unpack(data.read(8))[0]

        self.RevisedQueueSize = uatype_UInt32.unpack(data.read(4))[0]

        self.FilterResult = extensionobject_from_binary(data)

    def __str__(self):

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

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

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

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

    __repr__ = __str__

class ModifyMonitoredItemsParameters(FrozenClass):

    __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

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.StartTime = datetime.now()

        self.AggregateType = NodeId()

        self.ProcessingInterval = 0

        self.AggregateConfiguration = AggregateConfiguration()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(pack_datetime(self.StartTime))

        packet.append(self.AggregateType.to_binary())

        packet.append(uatype_Double.pack(self.ProcessingInterval))

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return AggregateFilter(data)

    def _binary_init(self, data):

        self.StartTime = unpack_datetime(data)

        self.AggregateType = NodeId.from_binary(data)

        self.ProcessingInterval = uatype_Double.unpack(data.read(8))[0]

        self.AggregateConfiguration = AggregateConfiguration.from_binary(data)

    def __str__(self):

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

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

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

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

    __repr__ = __str__

class MonitoringFilterResult(FrozenClass):

    __repr__ = __str__

class DeleteRawModifiedDetails(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar IsDeleteModified:

    :vartype IsDeleteModified: Boolean

    :ivar StartTime:

    :vartype StartTime: DateTime

    :ivar EndTime:

    :vartype EndTime: DateTime

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodeId = NodeId()

        self.IsDeleteModified = True

        self.StartTime = datetime.now()

        self.EndTime = datetime.now()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.NodeId.to_binary())

        packet.append(uatype_Boolean.pack(self.IsDeleteModified))

        packet.append(pack_datetime(self.StartTime))

        packet.append(pack_datetime(self.EndTime))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteRawModifiedDetails(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

        self.IsDeleteModified = uatype_Boolean.unpack(data.read(1))[0]

        self.StartTime = unpack_datetime(data)

        self.EndTime = unpack_datetime(data)

    def __str__(self):

        return 'DeleteRawModifiedDetails(' + 'NodeId:' + str(self.NodeId) + ', ' + \

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

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

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

    __repr__ = __str__

class DeleteAtTimeDetails(FrozenClass):

    __repr__ = __str__

class ReadEventDetails(FrozenClass):

    '''

    :ivar NumValuesPerNode:

    :vartype NumValuesPerNode: UInt32

    :ivar StartTime:

    :vartype StartTime: DateTime

    :ivar EndTime:

    :vartype EndTime: DateTime

    :ivar Filter:

    :vartype Filter: EventFilter

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NumValuesPerNode = 0

        self.StartTime = datetime.now()

        self.EndTime = datetime.now()

        self.Filter = EventFilter()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_UInt32.pack(self.NumValuesPerNode))

        packet.append(pack_datetime(self.StartTime))

        packet.append(pack_datetime(self.EndTime))

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ReadEventDetails(data)

    def _binary_init(self, data):

        self.NumValuesPerNode = uatype_UInt32.unpack(data.read(4))[0]

        self.StartTime = unpack_datetime(data)

        self.EndTime = unpack_datetime(data)

        self.Filter = EventFilter.from_binary(data)

    def __str__(self):

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

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

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

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

    __repr__ = __str__

class ReadRawModifiedDetails(FrozenClass):

    __repr__ = __str__

class MonitoredItemCreateRequest(FrozenClass):

    '''

    :ivar ItemToMonitor:

    :vartype ItemToMonitor: ReadValueId

    :ivar MonitoringMode:

    :vartype MonitoringMode: MonitoringMode

    :ivar RequestedParameters:

    :vartype 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(uatype_UInt32.pack(self.MonitoringMode.value))

        packet.append(self.RequestedParameters.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return MonitoredItemCreateRequest(data)

    def _binary_init(self, data):

        self.ItemToMonitor = ReadValueId.from_binary(data)

        self.MonitoringMode = MonitoringMode(uatype_UInt32.unpack(data.read(4))[0])

        self.RequestedParameters = MonitoringParameters.from_binary(data)

    def __str__(self):

        return 'MonitoredItemCreateRequest(' + 'ItemToMonitor:' + str(self.ItemToMonitor) + ', ' + \

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

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

    __repr__ = __str__

class MonitoredItemCreateResult(FrozenClass):