tdl-xoa-driver 1.2.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

xoa_driver/internals/hli_v2/modules/module_chimera.py

@@ -1,358 +0,0 @@
-import asyncio
-import functools
-import typing
-from typing import Self
-from xoa_driver.internals.commands import (
-    M_STATUS,
-    M_UPGRADE,
-    M_UPGRADEPROGRESS,
-    M_CFPTYPE,
-    M_COMMENT,
-    M_CAPABILITIES,
-    M_CLOCKPPB,
-    M_TXCLOCKSOURCE_NEW,
-    M_TXCLOCKSTATUS_NEW,
-    M_EMULBYPASS,
-    M_LATENCYMODE,
-    M_REVISION,
-    M_MEDIA,
-    M_MEDIASUPPORT,
-    M_TIMESYNC,
-    M_CLOCKSYNCSTATUS,
-    M_NAME,
-    M_CFPCONFIGEXT,
-    M_UPGRADEPAR,
-    M_VERSIONSTR,
-)
-
-from xoa_driver.internals.hli_v2 import revisions
-from xoa_driver.internals.utils.managers import ports_manager as pm
-from xoa_driver.internals.utils import attributes as utils
-from xoa_driver.internals.state_storage import modules_state
-from xoa_driver.v2 import ports
-from xoa_driver.internals.hli_v2.modules.modules_l23.module_l23_base import MediaModule, CfpModule
-from . import base_module as bm
-
-if typing.TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-    from . import __interfaces as m_itf
-
-
-class ChTXClock:
-    """
-    Advanced timing feature (Chimera).
-    """
-
-    def __init__(self, conn: "itf.IConnection", module_id: int) -> None:
-        self.source = M_TXCLOCKSOURCE_NEW(conn, module_id)
-        """
-        The source that drives the TX clock rate of the ports on the test module.
-        Representation of M_TXCLOCKSOURCE_NEW
-        """
-        self.status = M_TXCLOCKSTATUS_NEW(conn, module_id)
-        """
-        TX clock status of the test module.
-        Representation of M_TXCLOCKSTATUS_NEW
-        """
-
-
-class ChCFP:
-    """
-    CFP test module (Chimera).
-    """
-
-    def __init__(self, conn: "itf.IConnection", module: 'ModuleChimera') -> None:
-        self.type = M_CFPTYPE(conn, module.module_id)
-        """
-        The transceiver's CFP type currently inserted.
-        Representation of M_CFPTYPE
-        """
-        self.config = CfpModule(conn, module)
-        """
-        The CFP configuration of the test module.
-        Representation of CfpModule
-        """
-
-
-class ChUpgrade:
-    """
-    Upgrade test module (Chimera).
-    """
-
-    def __init__(self, conn: "itf.IConnection", module_id: int) -> None:
-        self.start = M_UPGRADE(conn, module_id)
-        """
-        Start the upgrade progress of the test module.
-        Representation of M_UPGRADE
-        """
-        self.progress = M_UPGRADEPROGRESS(conn, module_id)
-        """
-        Upgrade progress status of the test module.
-        Representation of M_UPGRADEPROGRESS
-        """
-        self.start_parallel = M_UPGRADEPAR(conn, module_id)
-        """
-        Start the parallel upgrade progress of the test module.
-
-        :type: M_UPGRADEPAR
-        """
-
-
-class ChTiming:
-    """Test module timing and clock configuration"""
-
-    def __init__(self, conn: "itf.IConnection", module_id: int) -> None:
-
-        self.source = M_TIMESYNC(conn, module_id)
-        """Timing source of the test module.
-
-        :type: M_TIMESYNC
-        """
-
-        self.clock_local_adjust = M_CLOCKPPB(conn, module_id)
-        """Time adjustment controlling of the local clock of the test module, which drives the TX rate of the test ports.
-
-        :type: M_CLOCKPPB
-        """
-
-        self.clock_sync_status = M_CLOCKSYNCSTATUS(conn, module_id)
-        """Test module's clock sync status.
-
-        :type: M_CLOCKSYNCSTATUS
-        """
-
-
-class ChAdvancedTiming:
-    """Advanced Timing config and control"""
-
-    def __init__(self, conn: "itf.IConnection", module_id: int) -> None:
-        self.clock = ChTXClock(conn, module_id)
-        """Advanced timing clock config and status
-        """
-
-
-class ModuleChimera(bm.BaseModule["modules_state.ModuleLocalState"]):
-    """
-    Representation of a Chimera module on physical tester.
-    """
-
-    def __init__(self, conn: "itf.IConnection", init_data: "m_itf.ModuleInitData") -> None:
-        super().__init__(conn, init_data)
-
-        self._local_states = modules_state.ModuleLocalState()
-
-        self.tx_clock = ChTXClock(conn, self.module_id)
-        """
-        TX clock config (Chimera).
-
-        :type: ChTXClock
-        """
-
-        self.timing = ChTiming(conn, self.module_id)
-        """
-        Timing config (Chimera).
-
-        :type: ChTiming
-        """
-
-        self.cfp = ChCFP(conn, self)
-        """
-        CFP test module (Chimera).
-
-        :type:  ChCFP
-        """
-
-        self.upgrade = ChUpgrade(conn, self.module_id)
-        """
-        Upgrade test module (Chimera).
-
-        :type: ChUpgrade
-        """
-
-        self.capabilities = M_CAPABILITIES(conn, self.module_id)
-        """
-        Test module's capabilities.
-
-        :type: M_CAPABILITIES
-        """
-
-        self.comment = M_COMMENT(conn, self.module_id)
-        """
-        Test module's description.
-
-        :type: M_COMMENT
-        """
-
-        self.status = M_STATUS(conn, self.module_id)
-        """
-        Test module's status.
-
-        :type: M_STATUS
-        """
-
-        self.clock_ppb = M_CLOCKPPB(conn, self.module_id)
-        """
-        Test module's local clock adjustment.
-
-        :type: M_CLOCKPPB
-        """
-
-        self.emulator_bypass_mode = M_EMULBYPASS(conn, self.module_id)
-        """
-        Bypass mode of the Chimera module.
-
-        :type: M_EMULBYPASS
-        """
-
-        self.latency_mode = M_LATENCYMODE(conn, self.module_id)
-        """
-        Latency mode of the Chimera module.
-
-        :type: M_LATENCYMODE
-        """
-
-        self.revision = M_REVISION(conn, self.module_id)
-        """Test module's model P/N name.
-
-        :type: M_REVISION
-        """
-
-        self.version_str = M_VERSIONSTR(conn, self.module_id)
-        """Module version number in the new format
-
-        :type: M_VERSIONSTR
-        """
-
-        self.media = MediaModule(conn, self)
-        """Test module's media type.
-
-        :type: MediaModule
-        """
-
-        self.available_speeds = M_MEDIASUPPORT(conn, self.module_id)
-        """Test module's available speeds.
-
-        :type: M_MEDIASUPPORT
-        """
-
-        self.name = M_NAME(conn, self.module_id)
-        """Test module's name.
-
-        :type: M_NAME
-        """
-
-        self.ports: pm.PortsManager["ports.PortChimera"] = pm.PortsManager(
-            conn=conn,
-            ports_type=ports.PortChimera,
-            module_id=self.module_id,
-            ports_count=self.ports_count
-        )
-        """
-        Port index manager of the Chimera module.
-        """
-
-    @property
-    def info(self) -> modules_state.ModuleLocalState:
-        return self._local_states
-
-    async def _setup(self) -> Self:
-        await asyncio.gather(
-            self._local_states.initiate(self),
-            self.ports.fill()
-        )
-        self._local_states.register_subscriptions(self)
-        return self
-
-    on_cfp_type_change = functools.partialmethod(utils.on_event, M_CFPTYPE)
-    """
-    Register a callback function to the event that the module's CFP type changes.
-    """
-
-    on_cfp_config_change = functools.partialmethod(utils.on_event, M_CFPCONFIGEXT)
-    """
-    Register a callback function to the event that the module's CFP configuration changes.
-    """
-
-    on_status_change = functools.partialmethod(utils.on_event, M_STATUS)
-    """
-    Register a callback function to the event that the module's model changes.
-    """
-
-    on_latency_mode_change = functools.partialmethod(utils.on_event, M_LATENCYMODE)
-    """
-    Register a callback function to the event that the module's latency mode changes.
-    """
-
-    on_media_change = functools.partialmethod(utils.on_event, M_MEDIA)
-    """
-    Register a callback to the event that the module's media and available speeds change.
-    """
-
-    on_media_support_change = functools.partialmethod(utils.on_event, M_MEDIASUPPORT)
-    """
-    Register a callback to the event that the module's supported media changes.
-    """
-
-    on_timing_source_change = functools.partialmethod(utils.on_event, M_TIMESYNC)
-    """
-    Register a callback to the event that the module's timesync mode changes.
-    """
-
-    on_timing_clock_local_adjust_change = functools.partialmethod(utils.on_event, M_CLOCKPPB)
-    """
-    Register a callback to the event that the module's clock adjustment ppb changes.
-    """
-
-    on_adv_timing_clock_tx_status_change = functools.partialmethod(utils.on_event, M_TXCLOCKSTATUS_NEW)
-    """Register a callback to the event that the module's TX clock status changes."""
-
-    on_adv_timing_clock_tx_source_change = functools.partialmethod(utils.on_event, M_TXCLOCKSOURCE_NEW)
-    """Register a callback to the event that the module's clock that drives the port TX rates changes."""
-
-
-@typing.final
-@revisions.register_chimera_module(rev="Chimera-100G-5S-2P")
-class MChi100G5S2P(ModuleChimera):
-    """Chimera module Chi-100G-5S-2P"""
-
-    def __init__(self, conn: "itf.IConnection", init_data: "m_itf.ModuleInitData") -> None:
-        super().__init__(conn, init_data)
-        self.ports: pm.PortsManager[ports.PChi100G5S2P] = pm.PortsManager(
-            conn=conn,
-            ports_type=ports.PChi100G5S2P,
-            module_id=self.module_id,
-            ports_count=self.ports_count
-        )
-        """Port index manager of Chi-100G-5S-2P"""
-
-
-@typing.final
-@revisions.register_chimera_module(rev="Chimera-100G-5S-2P[b]")
-class MChi100G5S2P_b(ModuleChimera):
-    """Chimera module Chi-100G-5S-2P[b]"""
-
-    def __init__(self, conn: "itf.IConnection", init_data: "m_itf.ModuleInitData") -> None:
-        super().__init__(conn, init_data)
-        self.ports: pm.PortsManager[ports.PChi100G5S2P_b] = pm.PortsManager(
-            conn=conn,
-            ports_type=ports.PChi100G5S2P_b,
-            module_id=self.module_id,
-            ports_count=self.ports_count
-        )
-        """Port index manager of Chi-100G-5S-2P[b]"""
-
-
-@typing.final
-@revisions.register_chimera_module(rev="Chimera-40G-2S-2P")
-class MChi40G2S2P(ModuleChimera):
-    """Chimera module Chi-40G-2S-2P"""
-
-    def __init__(self, conn: "itf.IConnection", init_data: "m_itf.ModuleInitData") -> None:
-        super().__init__(conn, init_data)
-        self.ports: pm.PortsManager[ports.PChi40G2S2P] = pm.PortsManager(
-            conn=conn,
-            ports_type=ports.PChi40G2S2P,
-            module_id=self.module_id,
-            ports_count=self.ports_count
-        )
-        """Port index manager of Chi-40G-2S-2P"""

xoa_driver/internals/hli_v2/modules/module_l23ve.py

@@ -1,58 +0,0 @@
-import asyncio
-import typing
-from typing import Self
-from xoa_driver.internals.commands import (
-    M_COMMENT,
-    M_CAPABILITIES,
-    M_MULTIUSER
-)
-from xoa_driver.v2 import ports
-from xoa_driver.internals.utils.managers import ports_manager as pm
-from xoa_driver.internals.state_storage import modules_state
-from . import base_module as bm
-if typing.TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-    from . import __interfaces as m_itf
-
-
-class ModuleL23VE(bm.BaseModule["modules_state.ModuleLocalState"]):
-    """
-    Representation of a L23 test module on virtual tester.
-    """
-    def __init__(self, conn: "itf.IConnection", init_data: "m_itf.ModuleInitData") -> None:
-        super().__init__(conn, init_data)
-
-        self._local_states = modules_state.ModuleLocalState()
-
-        self.comment = M_COMMENT(conn, self.module_id)
-        """Test module's description.
-        Representation of M_COMMENT
-        """
-        self.capabilities = M_CAPABILITIES(conn, self.module_id)
-        """Test module's capabilities.
-        Representation of M_CAPABILITIES
-        """
-        self.multiuser = M_MULTIUSER(conn, self.module_id)
-        """If multiple users are allowed to control the same test module.
-        Representation of M_MULTIUSER
-        """
-
-        self.ports: pm.PortsManager[ports.PortL23VE] = pm.PortsManager(
-            conn=conn,
-            ports_type=ports.PortL23VE,
-            module_id=self.module_id,
-            ports_count=self.ports_count
-        )
-        """L23 VE Port index manager of this test module."""
-
-    @property
-    def info(self) -> modules_state.ModuleLocalState:
-        return self._local_states
-
-    async def _setup(self) -> Self:
-        await asyncio.gather(
-            self._local_states.initiate(self),
-            self.ports.fill()
-        )
-        self._local_states.register_subscriptions(self)
-        return self

xoa_driver/internals/hli_v2/modules/module_l47.py

@@ -1,230 +0,0 @@
-import asyncio
-import functools
-import typing
-from typing import Self
-from xoa_driver.internals.commands import (
-    M_LICENSE_DEMO_INFO,
-    M_LICENSE_MAINTENANCE_INFO,
-    M_LICENSE_CWB_DETECTED,
-    M_LICENSE_UPDATE,
-    M_LICENSE_UPDATE_STATUS,
-    M_LICENSE_LIST_BSON,
-    M_LICENSE_ONLINE,
-    # M4_INT, #TODO: need to implement
-    # M4_STRING, #TODO: need to implement
-    # M4_HEX, #TODO: need to implement
-    M4_SYSTEMID,
-    M4_VERSIONNO,
-    M4_SYSTEM_STATUS,
-    M4_COMPATIBLE_CLIENT_VERSION,
-    M4_TIME,
-    M4_SYSTEM_TIME,
-    M4_MEM_INFO,
-    M4_CAPTURE_SIZE,
-    M4_LICENSE_INFO,
-    M4_REPLAY_PARSE_START,
-    M4_REPLAY_PARSE_STOP,
-    M4_REPLAY_PARSE_STATE,
-    M4_REPLAY_PARSER_PARAMS,
-    M4_REPLAY_FILE_LIST_BSON,
-    M4_REPLAY_FILE_LIST,
-    M4_CAPTURE_FILE_LIST_BSON,
-    M4_CAPTURE_FILE_LIST,
-    # M4_REPLAY_FILE_INFO_BSON, #TODO: need to implement
-    M4_REPLAY_FILE_DELETE,
-    M4_CAPTURE_FILE_DELETE,
-    M4E_MODE,
-    M4E_RESERVE,
-    M4_TLS_CIPHER_SUITES,
-)
-from xoa_driver.internals.hli_v2 import revisions
-from xoa_driver.internals.utils import attributes as utils
-from xoa_driver.internals.utils.managers import ports_manager as pm
-from xoa_driver.internals.state_storage import modules_state
-from xoa_driver.v2 import ports
-from . import base_module as bm
-if typing.TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-    from . import __interfaces as m_itf
-
-
-class License:
-    """License management for Vulcan"""
-    def __init__(self, conn: "itf.IConnection", module_id: int) -> None:
-        self.demo_info = M_LICENSE_DEMO_INFO(conn, module_id)
-        """Representation of M_LICENSE_DEMO_INFO
-        """
-        self.management_info = M_LICENSE_MAINTENANCE_INFO(conn, module_id)
-        """Representation of M_LICENSE_MAINTENANCE_INFO
-        """
-        self.clock_windback = M_LICENSE_CWB_DETECTED(conn, module_id)
-        """Representation of M_LICENSE_CWB_DETECTED
-        """
-        self.update = M_LICENSE_UPDATE(conn, module_id)
-        """Representation of M_LICENSE_UPDATE
-        """
-        self.update_status = M_LICENSE_UPDATE_STATUS(conn, module_id)
-        """Representation of M_LICENSE_UPDATE_STATUS
-        """
-        self.list_bson = M_LICENSE_LIST_BSON(conn, module_id)
-        """Representation of M_LICENSE_LIST_BSON
-        """
-        self.online_mode = M_LICENSE_ONLINE(conn, module_id)
-        """Representation of M_LICENSE_ONLINE
-        """
-
-
-class CaptureParse:
-    """Parse a captured pcap file"""
-    def __init__(self, conn: "itf.IConnection", module_id: int) -> None:
-        self.start = M4_REPLAY_PARSE_START(conn, module_id)
-        """Representation  of M4_REPLAY_PARSE_START
-        """
-        self.stop = M4_REPLAY_PARSE_STOP(conn, module_id)
-        """Representation  of M4_REPLAY_PARSE_STOP
-        """
-        self.state = M4_REPLAY_PARSE_STATE(conn, module_id)
-        """Representation  of M4_REPLAY_PARSE_STATE
-        """
-        self.parser_params = M4_REPLAY_PARSER_PARAMS(conn, module_id)
-        """Representation  of M4_REPLAY_PARSER_PARAMS
-        """
-
-
-class ReplayFile:
-    """The pcap files to replay"""
-    def __init__(self, conn: "itf.IConnection", module_id: int) -> None:
-        self.list_bson = M4_REPLAY_FILE_LIST_BSON(conn, module_id)
-        """Representation  of M4_REPLAY_FILE_LIST_BSON
-        """
-        self.list = M4_REPLAY_FILE_LIST(conn, module_id)
-        """Representation  of M4_REPLAY_FILE_LIST
-        """
-        # self.info_bson = M4_REPLAY_FILE_INFO_BSON(conn, module_id)  # TODO: need to implement
-        self.delete = M4_REPLAY_FILE_DELETE(conn, module_id)
-        """Representation  of M4_REPLAY_FILE_DELETE
-        """
-
-
-class Replay:
-    """PCAP replay"""
-    def __init__(self, conn: "itf.IConnection", module_id: int) -> None:
-        self.file = ReplayFile(conn, module_id)
-        """The pcap file to replay."""
-
-
-class Capture:
-    """Captured pcap file"""
-    def __init__(self, conn: "itf.IConnection", module_id: int) -> None:
-        self.size = M4_CAPTURE_SIZE(conn, module_id)
-        """Representation  of M4_CAPTURE_SIZE
-        """
-        self.file_list_bson = M4_CAPTURE_FILE_LIST_BSON(conn, module_id)
-        """Representation  of M4_CAPTURE_FILE_LIST_BSON
-        """
-        self.file_list = M4_CAPTURE_FILE_LIST(conn, module_id)
-        """Representation  of M4_CAPTURE_FILE_LIST
-        """
-        self.file_delete = M4_CAPTURE_FILE_DELETE(conn, module_id)
-        """Representation  of M4_CAPTURE_FILE_DELETE
-        """
-        self.parse = CaptureParse(conn, module_id)
-        """Parse a captured pcap file."""
-
-
-class PacketEngine:
-    """Packet engine"""
-    def __init__(self, conn: "itf.IConnection", module_id: int) -> None:
-        self.license_info = M4_LICENSE_INFO(conn, module_id)
-        """Representation  of M4_LICENSE_INFO
-        """
-        self.reserve = M4E_RESERVE(conn, module_id)
-        """Representation of M4E_RESERVE
-        """
-        self.mode = M4E_MODE(conn, module_id)
-        """Representation of M4E_MODE
-        """
-
-
-class ModuleSystem:
-    """L47 module info"""
-    def __init__(self, conn: "itf.IConnection", module_id: int) -> None:
-        self.id = M4_SYSTEMID(conn, module_id)
-        """Representation  of M4_SYSTEMID
-        """
-        self.status = M4_SYSTEM_STATUS(conn, module_id)
-        """Representation  of M4_SYSTEM_STATUS
-        """
-        self.time = M4_SYSTEM_TIME(conn, module_id)
-        """Representation  of M4_SYSTEM_TIME
-        """
-
-
-@revisions.register_vulcan_module(rev="Xena L47 Module")
-class ModuleL47(bm.BaseModule["modules_state.ModuleLocalState"]):
-    """
-    Representation of a L47 test module on a physical tester.
-    """
-    def __init__(self, conn: "itf.IConnection", init_data: "m_itf.ModuleInitData") -> None:
-        super().__init__(conn, init_data)
-
-        self._local_states = modules_state.ModuleLocalState()
-
-        self.version_number = M4_VERSIONNO(conn, self.module_id)
-        """Representation  of M4_VERSIONNO
-        """
-        self.compatible_client_version = M4_COMPATIBLE_CLIENT_VERSION(conn, self.module_id)
-        """Representation  of M4_COMPATIBLE_CLIENT_VERSION
-        """
-        self.time = M4_TIME(conn, self.module_id)
-        """Representation  of M4_TIME
-        """
-        self.tls_cipher = M4_TLS_CIPHER_SUITES(conn, self.module_id)
-        """Representation  of M4_TLS_CIPHER_SUITES
-        """
-        self.memory_info = M4_MEM_INFO(conn, self.module_id)  # Not sure if suppose to be here, maybe under ModuleSystem
-        """Representation  of M4_MEM_INFO
-        """
-
-        self.module_system = ModuleSystem(conn, self.module_id)
-        """L47 module info."""
-        self.license = License(conn, self.module_id)
-        """L47 license management."""
-        self.replay = Replay(conn, self.module_id)
-        """L47 pcap replay."""
-        self.capture = Capture(conn, self.module_id)
-        """L47 capture to pcap files."""
-        self.packet_engine = PacketEngine(conn, self.module_id)
-        """L47 packet engine."""
-
-        self.ports: pm.PortsManager[ports.PortL47] = pm.PortsManager(
-            conn=conn,
-            ports_type=ports.PortL47,
-            module_id=self.module_id,
-            ports_count=self.ports_count
-        )
-        """L47 Port index manager of this test module."""
-
-    @property
-    def info(self) -> modules_state.ModuleLocalState:
-        return self._local_states
-
-    async def _setup(self) -> Self:
-        await asyncio.gather(
-            self._local_states.initiate(self),
-            self.ports.fill()
-        )
-        self._local_states.register_subscriptions(self)
-        return self
-
-    on_license_demo_info_change = functools.partialmethod(utils.on_event, M_LICENSE_DEMO_INFO)
-    """Register a callback to the event that the module's demo license info changes."""
-
-    on_license_maintenance_info_change = functools.partialmethod(utils.on_event, M_LICENSE_MAINTENANCE_INFO)
-    """Register a callback to the event that the module's maintenance license info changes."""
-
-    on_replay_parse_state_change = functools.partialmethod(utils.on_event, M4_REPLAY_PARSE_STATE)
-    """Register a callback to the event that the module's parsing state of a captured pcap file changes."""
-
-    on_license_info_change = functools.partialmethod(utils.on_event, M4_LICENSE_INFO)
-    """Register a callback to the event that the module's L47 license info changes."""

xoa_driver/internals/hli_v2/modules/module_l47ve.py

@@ -1,8 +0,0 @@
-from . import module_l47 as l47m
-
-
-class ModuleL47VE(l47m.ModuleL47):
-    """
-    Representation of a L47 test module on a virtual tester.
-    """
-    ...