tdl-xoa-driver 1.3.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

xoa_driver/internals/hli_v2/indices/filter/base_filter.py

@@ -1,50 +0,0 @@
-from typing import (
-    TYPE_CHECKING,
-    List,
-    Type,
-    TypeVar,
-)
-from xoa_driver.internals.commands import (
-    PF_INDICES,
-    PF_CREATE,
-    PF_DELETE,
-    PF_ENABLE,
-    PF_COMMENT,
-    PF_CONDITION,
-)
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-    from xoa_driver.internals.utils import kind
-from xoa_driver.internals.utils.indices import observer as idx_obs
-from ..base_index import BaseIndex
-
-
-FT = TypeVar("FT")
-
-
-class BaseFilterIdx(BaseIndex):
-    """Base L23 Filter Index Manager"""
-    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
-        super().__init__(conn, kind, observer)
-
-        self.comment = PF_COMMENT(conn, *kind)
-        """Representation of PF_COMMENT"""
-        self.enable = PF_ENABLE(conn, *kind)
-        """Representation of PF_ENABLE"""
-        self.condition = PF_CONDITION(conn, *kind)
-        """Representation of PF_CONDITION"""
-
-    async def delete(self):
-        """Representation of PF_DELETE"""
-        await PF_DELETE(self._conn, *self.kind).set()
-        self._observer.notify(idx_obs.IndexEvents.DEL, self)
-
-    @classmethod
-    async def _fetch(cls, conn: "itf.IConnection", module_id: int, port_id: int) -> List[int]:
-        resp = await PF_INDICES(conn, module_id, port_id).get()
-        return list(resp.filter_xindices)
-
-    @classmethod
-    async def _new(cls: Type[FT], conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> FT:
-        await PF_CREATE(conn, *kind).set()
-        return cls(conn, kind, observer)

xoa_driver/internals/hli_v2/indices/filter/genuine_filter.py

@@ -1,17 +0,0 @@
-from typing import TYPE_CHECKING
-from xoa_driver.internals.commands import PF_STRING
-
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-    from xoa_driver.internals.utils import kind
-    from xoa_driver.internals.utils.indices import observer as idx_obs
-
-from .base_filter import BaseFilterIdx
-
-
-class GenuineFilterIdx(BaseFilterIdx):
-    """Genuine L23 Filter Index Manager"""
-    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
-        super().__init__(conn, kind, observer)
-        self.string = PF_STRING(conn, *kind)
-        """Representation of PF_STRING"""

xoa_driver/internals/hli_v2/indices/length_term.py

@@ -1,44 +0,0 @@
-from typing import (
-    TYPE_CHECKING,
-    List,
-    TypeVar,
-    Type,
-)
-from xoa_driver.internals.commands import (
-    PL_INDICES,
-    PL_CREATE,
-    PL_DELETE,
-    PL_LENGTH,
-)
-
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-    from xoa_driver.internals.utils import kind
-from xoa_driver.internals.utils.indices import observer as idx_obs
-from .base_index import BaseIndex
-
-
-LT = TypeVar("LT")
-
-
-class LengthTermIdx(BaseIndex):
-    """L23 Length Term Index Manager"""
-    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
-        super().__init__(conn, kind, observer)
-        self.length = PL_LENGTH(conn, *kind)
-        """Representation of pl_commands.PL_LENGTH"""
-
-    async def delete(self):
-        await PL_DELETE(self._conn, *self.kind).set()
-        """Representation of pl_commands.PL_DELETE"""
-        self._observer.notify(idx_obs.IndexEvents.DEL, self)
-
-    @classmethod
-    async def _fetch(cls, conn: "itf.IConnection", module_id: int, port_id: int) -> List[int]:
-        resp = await PL_INDICES(conn, module_id, port_id).get()
-        return list(resp.length_term_xindices)
-
-    @classmethod
-    async def _new(cls: Type[LT], conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> LT:
-        await PL_CREATE(conn, *kind).set()
-        return cls(conn, kind, observer)

xoa_driver/internals/hli_v2/indices/match_term.py

@@ -1,49 +0,0 @@
-from typing import (
-    List,
-    Type,
-    TypeVar,
-    TYPE_CHECKING,
-)
-from xoa_driver.internals.commands import (
-    PM_INDICES,
-    PM_CREATE,
-    PM_DELETE,
-    PM_PROTOCOL,
-    PM_POSITION,
-    PM_MATCH,
-)
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-    from xoa_driver.internals.utils import kind
-from xoa_driver.internals.utils.indices import observer as idx_obs
-from .base_index import BaseIndex
-
-MT = TypeVar("MT")
-
-
-class MatchTermIdx(BaseIndex):
-    """L23 Match Term Index Manager"""
-    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
-        super().__init__(conn, kind, observer)
-
-        self.protocol = PM_PROTOCOL(conn, *kind)
-        """Representation of pm_commands.PM_PROTOCOL"""
-        self.position = PM_POSITION(conn, *kind)
-        """Representation of pm_commands.PM_POSITION"""
-        self.match = PM_MATCH(conn, *kind)
-        """Representation of pm_commands.PM_MATCH"""
-
-    async def delete(self):
-        await PM_DELETE(self._conn, *self.kind).set()
-        """Representation of pm_commands.PM_DELETE"""
-        self._observer.notify(idx_obs.IndexEvents.DEL, self)
-
-    @classmethod
-    async def _fetch(cls, conn: "itf.IConnection", module_id: int, port_id: int) -> List[int]:
-        resp = await PM_INDICES(conn, module_id, port_id).get()
-        return list(resp.match_term_xindices)
-
-    @classmethod
-    async def _new(cls: Type[MT], conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> MT:
-        await PM_CREATE(conn, *kind).set()
-        return cls(conn, kind, observer)

xoa_driver/internals/hli_v2/indices/port_dataset.py

@@ -1,53 +0,0 @@
-from typing import (
-    TYPE_CHECKING,
-    List,
-    TypeVar,
-    Type,
-)
-from xoa_driver.internals.commands import (
-    PD_INDICES,
-    PD_CREATE,
-    PD_DELETE,
-    PD_ENABLE,
-    PD_SOURCE,
-    PD_RANGE,
-    PD_SAMPLES,
-)
-
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-    from xoa_driver.internals.utils import kind
-from xoa_driver.internals.utils.indices import observer as idx_obs
-from .base_index import BaseIndex
-
-
-PD = TypeVar("PD")
-
-
-class PortDatasetIdx(BaseIndex):
-    """L23 Histogram Index Manager"""
-    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
-        super().__init__(conn, kind, observer)
-        self.enable = PD_ENABLE(conn, *kind)
-        """Representation of pd_commands.PD_ENABLE"""
-        self.source = PD_SOURCE(conn, *kind)
-        """Representation of pd_commands.PD_SOURCE"""
-        self.range = PD_RANGE(conn, *kind)
-        """Representation of pd_commands.PD_RANGE"""
-        self.samples = PD_SAMPLES(conn, *kind)
-        """Representation of pd_commands.PD_SAMPLES"""
-
-    async def delete(self):
-        await PD_DELETE(self._conn, *self.kind).set()
-        """Representation of pd_commands.PD_ENABLE"""
-        self._observer.notify(idx_obs.IndexEvents.DEL, self)
-
-    @classmethod
-    async def _fetch(cls, conn: "itf.IConnection", module_id: int, port_id: int) -> List[int]:
-        resp = await PD_INDICES(conn, module_id, port_id).get()
-        return list(resp.histogram_indices)
-
-    @classmethod
-    async def _new(cls: Type[PD], conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> PD:
-        await PD_CREATE(conn, *kind).set()
-        return cls(conn, kind, observer)

xoa_driver/internals/hli_v2/indices/streams/base_stream.py

@@ -1,234 +0,0 @@
-from typing import (
-    List,
-    Type,
-    TypeVar,
-    TYPE_CHECKING,
-)
-from xoa_driver.internals.commands import (
-    PS_INDICES,
-    PS_CREATE,
-    PS_DELETE,
-    PS_ENABLE,
-    PS_PACKETLIMIT,
-    PS_COMMENT,
-    PS_TPLDID,
-    PS_ARPREQUEST,
-    PS_PINGREQUEST,
-    PS_MODIFIEREXTRANGE,
-    PS_MODIFIERRANGE,
-    PS_RATEFRACTION,
-    PS_RATEPPS,
-    PS_RATEL2BPS,
-    PS_BURST,
-    PS_PACKETHEADER,
-    PS_HEADERPROTOCOL,
-    PS_MODIFIERCOUNT,
-    PS_MODIFIER,
-    PS_PACKETLENGTH,
-    PS_PAYLOAD,
-    PS_IPV4GATEWAY,
-    PS_IPV6GATEWAY,
-    PS_BURSTGAP,
-    PS_INJECTSEQERR,
-    PS_INJECTMISERR,
-    PS_INJECTPLDERR,
-    PS_INJECTTPLDERR,
-    PS_MODIFIEREXT,
-    PS_MODIFIEREXTCOUNT,
-    PS_CDFOFFSET,
-    PS_CDFCOUNT,
-    PS_CDFDATA,
-    PS_EXTPAYLOAD,
-    PS_PFCPRIORITY,
-    PS_AUTOADJUST,
-    PS_OPTIONS,
-)
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-    from xoa_driver.internals.utils import kind
-from xoa_driver.internals.utils.indices import observer as idx_obs
-from xoa_driver.internals.utils.indices import header_modifier_manager as hmm
-from ..base_index import BaseIndex
-
-
-class SRate:
-    """L23 Stream Rate Configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, stream_idx: int) -> None:
-        self.fraction = PS_RATEFRACTION(conn, module_id, port_id, stream_idx)
-        """Representation of PS_RATEFRACTION"""
-        self.pps = PS_RATEPPS(conn, module_id, port_id, stream_idx)
-        """Representation of PS_RATEPPS"""
-        self.l2bps = PS_RATEL2BPS(conn, module_id, port_id, stream_idx)
-        """Representation of PS_RATEL2BPS"""
-
-
-class HModifierExtended:
-    """L23 Extended Modifier Configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, stream_idx: int, modifier_idx: int) -> None:
-        self.specification = PS_MODIFIEREXT(conn, module_id, port_id, stream_idx, modifier_idx)
-        """Representation of PS_MODIFIEREXT"""
-        self.range = PS_MODIFIEREXTRANGE(conn, module_id, port_id, stream_idx, modifier_idx)
-        """Representation of PS_MODIFIEREXTRANGE"""
-
-
-class HModifier:
-    """L23 Modifier Configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, stream_idx: int, modifier_idx: int) -> None:
-        self.specification = PS_MODIFIER(conn, module_id, port_id, stream_idx, modifier_idx)
-        """Representation of PS_MODIFIEREXTRANGE"""
-        self.range = PS_MODIFIERRANGE(conn, module_id, port_id, stream_idx, modifier_idx)
-        """Representation of PS_MODIFIERRANGE"""
-
-
-class SCustomDataField:
-    """L23 Custom Data Field Configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, stream_idx: int) -> None:
-        self.__conn = conn
-        self.__module_id = module_id
-        self.__port_id = port_id
-        self.__stream_idx = stream_idx
-
-        self.offset = PS_CDFOFFSET(conn, module_id, port_id, stream_idx)
-        """Representation of PS_CDFOFFSET"""
-        self.count = PS_CDFCOUNT(conn, module_id, port_id, stream_idx)
-        """Representation of PS_CDFCOUNT"""
-
-    def data(self, cdf_index: int) -> "PS_CDFDATA":
-        """Representation of PS_CDFDATA"""
-        return PS_CDFDATA(self.__conn, self.__module_id, self.__port_id, self.__stream_idx, cdf_index)
-
-
-class SInjectError:
-    """L23 Error Injection Configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, stream_idx: int) -> None:
-        self.sequence = PS_INJECTSEQERR(conn, module_id, port_id, stream_idx)
-        """Representation of PS_INJECTSEQERR"""
-        self.misorder = PS_INJECTMISERR(conn, module_id, port_id, stream_idx)
-        """Representation of PS_INJECTMISERR"""
-        self.payload_integrity = PS_INJECTPLDERR(conn, module_id, port_id, stream_idx)
-        """Representation of PS_INJECTPLDERR"""
-        self.test_payload = PS_INJECTTPLDERR(conn, module_id, port_id, stream_idx)
-        """Representation of PS_INJECTTPLDERR"""
-
-
-class SRequest:
-    """L23 Request Configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, stream_idx: int) -> None:
-        self.arp = PS_ARPREQUEST(conn, module_id, port_id, stream_idx)
-        """Representation of PS_ARPREQUEST"""
-        self.ping = PS_PINGREQUEST(conn, module_id, port_id, stream_idx)
-        """Representation of PS_PINGREQUEST"""
-
-
-class SPayload:
-    """L23 Payload Configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, stream_idx: int) -> None:
-        self.content = PS_PAYLOAD(conn, module_id, port_id, stream_idx)
-        """Representation of PS_PAYLOAD"""
-        self.extended = PS_EXTPAYLOAD(conn, module_id, port_id, stream_idx)
-        """Representation of PS_EXTPAYLOAD"""
-
-
-class SGateway:
-    """L23 Gateway Configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, stream_idx: int) -> None:
-        self.ipv4 = PS_IPV4GATEWAY(conn, module_id, port_id, stream_idx)
-        """Representation of PS_IPV4GATEWAY"""
-        self.ipv6 = PS_IPV6GATEWAY(conn, module_id, port_id, stream_idx)
-        """Representation of PS_IPV6GATEWAY"""
-
-
-class SPHeader:
-    """L23 Stream Header Configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, stream_idx: int) -> None:
-        self.data = PS_PACKETHEADER(conn, module_id, port_id, stream_idx)
-        """Representation of PS_PACKETHEADER"""
-        self.protocol = PS_HEADERPROTOCOL(conn, module_id, port_id, stream_idx)
-        """Representation of PS_HEADERPROTOCOL"""
-        self.modifiers: "hmm.ModifiersManager[HModifier]" = hmm.ModifiersManager(
-            conn,
-            (module_id, port_id, stream_idx),
-            PS_MODIFIERCOUNT,
-            HModifier
-        )
-        """L23 stream modifier index manager"""
-        self.modifiers_extended: "hmm.ModifiersManager[HModifierExtended]" = hmm.ModifiersManager(
-            conn,
-            (module_id, port_id, stream_idx),
-            PS_MODIFIEREXTCOUNT,
-            HModifierExtended
-        )
-        """L23 stream extended modifier index manager"""
-
-
-class SPacket:
-    """L23 Packet Configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, stream_idx: int) -> None:
-        self.limit = PS_PACKETLIMIT(conn, module_id, port_id, stream_idx)
-        """Representation of PS_PACKETLIMIT"""
-        self.length = PS_PACKETLENGTH(conn, module_id, port_id, stream_idx)
-        """Representation of PS_PACKETLENGTH"""
-        self.header = SPHeader(conn, module_id, port_id, stream_idx)
-        """Packet header config"""
-        self.auto_adjust = PS_AUTOADJUST(conn, module_id, port_id, stream_idx)
-        """Auto adjust the packet length distribution of the stream."""
-
-
-class SBurst:
-    """L23 Stream Burst Configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, stream_idx: int) -> None:
-        self.burstiness = PS_BURST(conn, module_id, port_id, stream_idx)
-        """Representation of PS_BURST"""
-        self.gap = PS_BURSTGAP(conn, module_id, port_id, stream_idx)
-        """Representation of PS_BURSTGAP"""
-
-
-BS = TypeVar("BS")
-
-
-class BaseStreamIdx(BaseIndex):
-    """Base L23 Stream Index Manager"""
-    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
-        super().__init__(conn, kind, observer)
-
-        self.comment = PS_COMMENT(conn, *kind)
-        """Representation of PS_COMMENT"""
-        self.enable = PS_ENABLE(conn, *kind)
-        """Representation of PS_ENABLE"""
-        self.tpld_id = PS_TPLDID(conn, *kind)
-        """Representation of PS_TPLDID"""
-        self.priority_flow = PS_PFCPRIORITY(conn, *kind)
-        """Representation of PS_PFCPRIORITY"""
-        self.payload = SPayload(conn, *kind)
-        """L23 stream payload config"""
-        self.request = SRequest(conn, *kind)
-        """L23 stream request config"""
-        self.packet = SPacket(conn, *kind)
-        """L23 stream packet config"""
-        self.burst = SBurst(conn, *kind)
-        """L23 stream burst config"""
-        self.gateway = SGateway(conn, *kind)
-        """L23 stream gateway config"""
-        self.inject_err = SInjectError(conn, *kind)
-        """L23 stream error injections config"""
-        self.cdf = SCustomDataField(conn, *kind)
-        """L23 stream custom data field config"""
-        self.rate = SRate(conn, *kind)
-        """L23 stream rate config"""
-        self.options = PS_OPTIONS(conn, *kind)
-        """L23 stream options"""
-
-    async def delete(self):
-        """Representation of PS_DELETE"""
-        await PS_DELETE(self._conn, *self.kind).set()
-        self._observer.notify(idx_obs.IndexEvents.DEL, self)
-
-    @classmethod
-    async def _fetch(cls, conn: "itf.IConnection", module_id: int, port_id: int) -> List[int]:
-        resp = await PS_INDICES(conn, module_id, port_id).get()
-        return list(resp.stream_indices)
-
-    @classmethod
-    async def _new(cls: Type[BS], conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> BS:
-        await PS_CREATE(conn, *kind).set()
-        return cls(conn, kind, observer)

xoa_driver/internals/hli_v2/indices/streams/genuine_stream.py

@@ -1,32 +0,0 @@
-from typing import TYPE_CHECKING
-from xoa_driver.internals.commands import (
-    PS_INSERTFCS,
-    PS_INJECTFCSERR,
-)
-from .base_stream import (
-    BaseStreamIdx,
-    SInjectError
-)
-
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-    from xoa_driver.internals.utils import kind
-    from xoa_driver.internals.utils.indices import observer as idx_obs
-
-
-class GSInjectError(SInjectError):
-    """Error Injection configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, stream_idx: int) -> None:
-        super().__init__(conn, module_id, port_id, stream_idx)
-        self.frame_checksum = PS_INJECTFCSERR(conn, module_id, port_id, stream_idx)
-        """Representation of PS_INJECTFCSERR"""
-
-
-class GenuineStreamIdx(BaseStreamIdx):
-    """Genuine L23 Stream Index Manager"""
-    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
-        super().__init__(conn, kind, observer)
-        self.insert_packets_checksum = PS_INSERTFCS(conn, *kind)
-        """Representation of PS_INSERTFCS"""
-        self.inject_err = GSInjectError(conn, *kind)
-        """Error injection configuration"""

xoa_driver/internals/hli_v2/modules/__interfaces.py

@@ -1,21 +0,0 @@
-import typing
-
-if typing.TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-
-
-class ModuleInitData(typing.Protocol):
-    module_id: int
-    ports_count: int
-    revision: str
-
-
-class IPort(typing.Protocol):
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
-        ...
-
-    # def __await__(self):
-    #     ...
-
-    # async def _setup(self):
-    #     ...

xoa_driver/internals/hli_v2/modules/base_module.py

@@ -1,125 +0,0 @@
-
-import functools
-from typing import (
-    TYPE_CHECKING,
-    TypeVar,
-    Generic
-)
-from abc import (
-    ABC,
-    abstractmethod,
-)
-from typing import Self
-from xoa_driver.internals.commands import enums
-from xoa_driver.internals.commands import (
-    M_MODEL,
-    M_PORTCOUNT,
-    M_RESERVATION,
-    M_RESERVEDBY,
-    M_SERIALNO,
-    M_VERSIONNO
-)
-from xoa_driver.internals.utils import attributes as utils
-
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-    from . import __interfaces as m_itf
-    from xoa_driver.internals.state_storage import modules_state
-
-
-T = TypeVar('T', bound="modules_state.ModuleLocalState")
-
-
-class BaseModule(ABC, Generic[T]):
-    """
-    Representation of a Valkyrie module on a physical tester.
-    """
-    def __init__(self, conn: "itf.IConnection", init_data: "m_itf.ModuleInitData") -> None:
-        self._conn = conn
-        self.module_id = init_data.module_id
-        self.ports_count = init_data.ports_count
-        self.reservation = M_RESERVATION(self._conn, self.module_id)
-        """Test module's reservation action.
-        Representation of M_RESERVATION
-        """
-
-        self.reserved_by = M_RESERVEDBY(self._conn, self.module_id)
-        """Test module's reservation status.
-        Representation of M_RESERVEDBY
-        """
-
-        self.model = M_MODEL(self._conn, self.module_id)
-        """Test module's model.
-        Representation of M_MODEL
-        """
-
-        self.serial_number = M_SERIALNO(self._conn, self.module_id)
-        """Test module's serial number.
-        Representation of M_SERIALNO
-        """
-
-        self.version_number = M_VERSIONNO(self._conn, self.module_id)
-        """Test module's version number.
-        Representation of M_VERSIONNO
-        """
-
-        self.port_count = M_PORTCOUNT(self._conn, self.module_id)
-        """Max port count of the test module.
-        Representation of M_PORTCOUNT
-        """
-
-    @property
-    @abstractmethod
-    def info(self) -> T:
-        """
-        Module local info.
-        """
-        raise NotImplementedError()
-
-    def __await__(self):
-        return self._setup().__await__()
-
-    @abstractmethod
-    async def _setup(self) -> Self:
-        raise NotImplementedError()
-
-    def _check_identity(self, request) -> bool:
-        return self.module_id == request.header.module_index
-
-    def __is_reservation(self, reserved_status: enums.ReservedStatus) -> bool:
-        return self.info.reservation == reserved_status
-
-    is_released = functools.partialmethod(__is_reservation, enums.ReservedStatus.RELEASED)
-    """
-    Validate if the module is released.
-    """
-
-    is_reserved_by_me = functools.partialmethod(__is_reservation, enums.ReservedStatus.RESERVED_BY_YOU)
-    """
-    Validate if the module is reserved by me.
-    """
-
-    on_reservation_change = functools.partialmethod(utils.on_event, M_RESERVATION)
-    """
-    Register a callback to the event that the module's reservation status changes.
-    """
-
-    on_reserved_by_change = functools.partialmethod(utils.on_event, M_RESERVEDBY)
-    """
-    Register a callback to the event that the module's ownership status changes.
-    """
-
-    on_model_change = functools.partialmethod(utils.on_event, M_MODEL)
-    """
-    Register a callback to the event that the module's legacy model changes.
-    """
-
-    on_serial_number_change = functools.partialmethod(utils.on_event, M_SERIALNO)
-    """
-    Register a callback to the event that the module's serial number status changes.
-    """
-
-    on_version_number_change = functools.partialmethod(utils.on_event, M_VERSIONNO)
-    """
-    Register a callback to the event that the module's version number status changes.
-    """