tdl-xoa-driver 1.0.0__py3-none-any.whl

xoa_driver/internals/hli_v2/modules/module_chimera.py

@@ -0,0 +1,358 @@
+import asyncio
+import functools
+import typing
+from typing_extensions 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

@@ -0,0 +1,58 @@
+import asyncio
+import typing
+from typing_extensions 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

@@ -0,0 +1,230 @@
+import asyncio
+import functools
+import typing
+from typing_extensions 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

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