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

xoa_driver/internals/hli_v1/modules/modules_l23/family_m.py

@@ -0,0 +1,25 @@
+import typing
+from xoa_driver import ports
+from xoa_driver.internals.hli_v1 import revisions
+from xoa_driver.internals.utils.managers import ports_manager as pm
+
+if typing.TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+    from .. import __interfaces as m_itf
+
+from .module_l23_base import ModuleL23
+
+
+@typing.final
+@revisions.register_valkyrie_module(rev="Odin-1G-3S-6P-T1-RJ45")
+class MOdin1G3S6PT1RJ45(ModuleL23):
+    """Test module Odin-1G-3S-6P-T1-RJ45"""
+    def __init__(self, conn: "itf.IConnection", init_data: "m_itf.ModuleInitData") -> None:
+        super().__init__(conn, init_data)
+        self.ports: pm.PortsManager[ports.POdin1G3S6PT1RJ45] = pm.PortsManager(
+            conn=conn,
+            ports_type=ports.POdin1G3S6PT1RJ45,
+            module_id=self.module_id,
+            ports_count=self.ports_count
+        )
+        """Port Index Manager of Odin-1G-3S-6P-T1-RJ45"""

xoa_driver/internals/hli_v1/modules/modules_l23/family_n.py

@@ -0,0 +1,40 @@
+import typing
+from xoa_driver import ports
+from xoa_driver.internals.hli_v1 import revisions
+from xoa_driver.internals.utils.managers import ports_manager as pm
+
+if typing.TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+    from .. import __interfaces as m_itf
+
+from .module_l23_base import ModuleL23
+
+
+@typing.final
+@revisions.register_valkyrie_module(rev="Odin-40G-2S-2P")
+class MOdin40G2S2P(ModuleL23):
+    """Test module Odin-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.POdin40G2S2P] = pm.PortsManager(
+            conn=conn,
+            ports_type=ports.POdin40G2S2P,
+            module_id=self.module_id,
+            ports_count=self.ports_count
+        )
+        """Port Index Manager of Odin-40G-2S-2P"""
+
+
+@typing.final
+@revisions.register_valkyrie_module(rev="Odin-40G-2S-2P-B")
+class MOdin40G2S2PB(ModuleL23):
+    """Test module Odin-40G-2S-2P-B"""
+    def __init__(self, conn: "itf.IConnection", init_data: "m_itf.ModuleInitData") -> None:
+        super().__init__(conn, init_data)
+        self.ports: pm.PortsManager[ports.POdin40G2S2PB] = pm.PortsManager(
+            conn=conn,
+            ports_type=ports.POdin40G2S2PB,
+            module_id=self.module_id,
+            ports_count=self.ports_count
+        )
+        """Port Index Manager of Odin-40G-2S-2P-B"""

xoa_driver/internals/hli_v1/modules/modules_l23/module_l23_base.py

@@ -0,0 +1,383 @@
+from __future__ import annotations
+import asyncio
+import functools
+import typing
+from typing_extensions import Self
+from xoa_driver.internals.commands import (
+    M_MEDIA,
+    M_STATUS,
+    M_UPGRADE,
+    M_UPGRADEPROGRESS,
+    M_TIMESYNC,
+    M_CFPTYPE,
+    M_CFPCONFIGEXT,
+    M_COMMENT,
+    # M_TIMEADJUSTMENT,
+    M_CAPABILITIES,
+    M_MEDIASUPPORT,
+    M_FPGAREIMAGE,
+    M_MULTIUSER,
+    M_CLOCKPPB,
+    M_SMAINPUT,
+    M_SMAOUTPUT,
+    M_SMASTATUS,
+    M_NAME,
+    M_REVISION,
+    M_CLOCKSYNCSTATUS,
+    M_TXCLOCKSOURCE_NEW,
+    M_TXCLOCKSTATUS_NEW,
+    M_TXCLOCKFILTER_NEW,
+    M_UPGRADEPAR,
+    M_VERSIONSTR,
+)
+
+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.enums import MediaConfigurationType
+from xoa_driver.internals.core.token import Token
+from .. import base_module as bm
+from .. import __interfaces as m_itf
+
+if typing.TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+    from xoa_driver.internals.hli_v1.modules.module_chimera import ModuleChimera
+
+
+class TXClock:
+    """Advanced timing clock"""
+
+    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.
+
+        :type: M_TXCLOCKSOURCE_NEW
+        """
+
+        self.status = M_TXCLOCKSTATUS_NEW(conn, module_id)
+        """TX clock status of the test module.
+
+        :type: M_TXCLOCKSTATUS_NEW
+        """
+
+        self.filter = M_TXCLOCKFILTER_NEW(conn, module_id)
+        """Loop bandwidth on the TX clock filter of the test module.
+
+        :type: M_TXCLOCKFILTER_NEW
+        """
+
+
+class SMA:
+    """SMA connector"""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int) -> None:
+        self.input = M_SMAINPUT(conn, module_id)
+        """SMA input of the test module.
+
+        :type: M_SMAINPUT
+        """
+
+        self.output = M_SMAOUTPUT(conn, module_id)
+        """SMA output of the test module.
+
+        :type: M_SMAOUTPUT
+        """
+
+        self.status = M_SMASTATUS(conn, module_id)
+        """SMA input status of the test module.
+
+        :type: M_SMASTATUS
+        """
+
+
+class AdvancedTiming:
+    """Advanced Timing config and control"""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int) -> None:
+        self.clock_tx = TXClock(conn, module_id)
+        """Advanced timing clock config and status
+
+        :type: TXClock
+        """
+
+        self.sma = SMA(conn, module_id)
+        """SMA connector
+
+        :type: SMA
+        """
+
+
+class ExtendedToken:
+    def __init__(
+        self, token: Token, module: typing.Union["ModuleL23", "ModuleChimera"]
+    ) -> None:
+        self.__token = token
+        self.__module = module
+
+    def __await__(self):
+        return self.__ask_then().__await__()
+
+    async def __ask_then(self):
+        r = await self.__token
+        p_counts = (await self.__module.port_count.get()).port_count
+        if self.__module.ports is not None:
+            changed = self.__module.ports.reinit(p_counts)
+            if changed:
+                await self.__module.ports.fill()
+        return r
+
+
+class MediaModule:
+    def __init__(self, conn: "itf.IConnection", module: typing.Union["ModuleL23", "ModuleChimera"]) -> None:
+        self.__media = M_MEDIA(conn, module.module_id)
+        self.__module = module
+
+    def get(self) -> Token:
+        return self.__media.get()
+
+    def set(self, media_config: MediaConfigurationType) -> ExtendedToken:
+        return ExtendedToken(self.__media.set(media_config), self.__module)
+    
+
+class CfpModule:
+    def __init__(self, conn: "itf.IConnection", module: typing.Union["ModuleL23", "ModuleChimera"]) -> None:
+        self.__cfpconfigext = M_CFPCONFIGEXT(conn, module.module_id)
+        self.__module = module
+    
+    def get(self) -> Token:
+        return self.__cfpconfigext.get()
+
+    def set(self, portspeed_list: typing.List[int]) -> ExtendedToken:
+        return ExtendedToken(self.__cfpconfigext.set(portspeed_list), self.__module)
+
+
+class CFP:
+    """Test module CFP"""
+
+    def __init__(self, conn: "itf.IConnection", module: typing.Union["ModuleL23", "ModuleChimera"]) -> None:
+        self.type = M_CFPTYPE(conn, module.module_id)
+        """The transceiver's CFP type currently inserted.
+
+        :type: M_CFPTYPE
+        """
+
+        self.config = CfpModule(conn, module)
+        """The CFP configuration of the test module.
+
+        :type: CfpModule
+        """
+
+
+class MTiming:
+    """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 MUpgrade:
+    """Test module upgrade"""
+
+    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.
+
+        :type: M_UPGRADE
+        """
+
+        self.progress = M_UPGRADEPROGRESS(conn, module_id)
+        """Upgrade progress status of the test module.
+
+        :type: M_UPGRADEPROGRESS
+        """
+
+        self.reload_image = M_FPGAREIMAGE(conn, module_id)
+        """Reload the FPGA image of the test module.
+
+        :type: M_FPGAREIMAGE
+        """
+        self.start_parallel = M_UPGRADEPAR(conn, module_id)
+        """
+        Start the parallel upgrade progress of the test module.
+
+        :type: M_UPGRADEPAR
+        """
+
+
+class ModuleL23(bm.BaseModule["modules_state.ModuleL23LocalState"]):
+    """
+    This is a conceptual class of L23 test module on a Valkyrie tester.
+
+    """
+
+    def __init__(self, conn: "itf.IConnection", init_data: "m_itf.ModuleInitData") -> None:
+        super().__init__(conn, init_data)
+
+        self._local_states = modules_state.ModuleL23LocalState()
+
+        self.name = M_NAME(conn, self.module_id)
+        """Test module's name.
+
+        :type: M_NAME
+        """
+
+        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.media = MediaModule(conn, self)
+        """Test module's media type.
+
+        :type: ModuleMedia
+        """
+
+        self.available_speeds = M_MEDIASUPPORT(conn, self.module_id)
+        """Test module's available speeds.
+
+        :type: M_MEDIASUPPORT
+        """
+
+        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.multiuser = M_MULTIUSER(conn, self.module_id)
+        """If multiple users are allowed to control the same test module.
+
+        :type: M_MULTIUSER
+        """
+
+        self.capabilities = M_CAPABILITIES(conn, self.module_id)
+        """Test module's capabilities.
+
+        :type: M_CAPABILITIES
+        """
+
+        self.timing = MTiming(conn, self.module_id)
+        """Test module's timing configuration.
+
+        :type: MTiming
+        """
+
+        self.advanced_timing = AdvancedTiming(conn, self.module_id)
+        """Test module's advanced timing configuration.
+
+        :type: AdvancedTiming
+        """
+
+        self.cfp = CFP(conn, self)
+        """Test module's CFP configuration.
+
+        :type: CFP
+        """
+
+        self.upgrade = MUpgrade(conn, self.module_id)
+        """Test module's upgrade settings.
+
+        :type: MUpgrade
+        """
+
+        self.ports: typing.Optional[pm.PortsManager] = None
+        """L23 Port Index Manager of the test module.
+
+        :type: PortsManager
+        """
+
+    @property
+    def info(self) -> modules_state.ModuleL23LocalState:
+        """Return the module's local state
+
+        :return: the module's local state
+        :rtype: ModuleL23LocalState
+        """
+        return self._local_states
+
+    async def _setup(self) -> Self:
+        if self.ports is None:
+            raise NotImplementedError("Ports manager type are not defined.")  # Maybe can be better solution then this...
+        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 to the event that the module's CFP type (:class:`M_CFPTYPE`) changes."""
+
+    on_cfp_config_change = functools.partialmethod(utils.on_event, M_CFPCONFIGEXT)
+    """Register a callback to the event that the module's CFP configuration changes."""
+
+    on_status_change = functools.partialmethod(utils.on_event, M_STATUS)
+    """Register a callback to the event that the module's status changes."""
+
+    on_revision_change = functools.partialmethod(utils.on_event, M_REVISION)
+    """Register a callback to the event that the module's model type changes."""
+
+    on_name_change = functools.partialmethod(utils.on_event, M_NAME)
+    """Register a callback to the event that the module's name 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."""
+
+    on_adv_timing_clock_tx_filter_change = functools.partialmethod(utils.on_event, M_TXCLOCKFILTER_NEW)
+    """Register a callback to the event that the module's loop bandwidth on the TX clock filter changes."""
+
+    on_adv_timing_sma_status_change = functools.partialmethod(utils.on_event, M_SMASTATUS)
+    """Register a callback to the event that the module's SMA status changes."""
+
+    on_adv_timing_sma_input_change = functools.partialmethod(utils.on_event, M_SMAINPUT)
+    """Register a callback to the event that the module's SMA input function changes."""
+
+    on_adv_timing_sma_output_change = functools.partialmethod(utils.on_event, M_SMAOUTPUT)
+    """Register a callback to the event that the module's SMA output function changes."""
+
+    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_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_comment_change = functools.partialmethod(utils.on_event, M_COMMENT)
+    """Register a callback to the event that the module's description 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."""

xoa_driver/internals/hli_v1/ports/base_port.py

@@ -0,0 +1,125 @@
+import functools
+from typing_extensions import Self
+from abc import (
+    ABC,
+    abstractmethod,
+)
+from typing import (
+    TYPE_CHECKING,
+    TypeVar,
+    Generic,
+)
+from xoa_driver.internals.commands import enums
+from xoa_driver.internals.commands import (
+    P_RESERVATION,
+    P_RESERVEDBY,
+    P_RESET,
+    P_COMMENT,
+    P_INTERFACE,
+    P_RECEIVESYNC,
+)
+from xoa_driver.internals.state_storage import ports_state
+from xoa_driver.internals.utils import attributes as utils
+from xoa_driver.internals.utils import kind
+
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+
+
+PortStateStorage = TypeVar('PortStateStorage', bound="ports_state.PortLocalState")
+
+
+class BasePort(ABC, Generic[PortStateStorage]):
+    """Layout which is relevant to all ports."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self._conn = conn
+        self.kind = kind.PortKind(module_id, port_id)
+        self.sync_status = P_RECEIVESYNC(conn, module_id, port_id)
+        """Port sync status.
+        
+        :type: P_RECEIVESYNC
+        """
+        self.interface = P_INTERFACE(conn, module_id, port_id)
+        """Physical interface type of the port.
+        
+        :type: P_INTERFACE
+        """
+        self.reservation = P_RESERVATION(self._conn, *self.kind)
+        """Port reservation action.
+        
+        :type: P_RESERVATION
+        """
+        self.reserved_by = P_RESERVEDBY(self._conn, *self.kind)
+        """Port reservation status.
+        
+        :type: P_RESERVEDBY
+        """
+        self.reset = P_RESET(self._conn, *self.kind)
+        """Port reset action.
+        
+        :type: P_RESET
+        """
+        self.comment = P_COMMENT(self._conn, *self.kind)
+        """Port description.
+        
+        :type: P_COMMENT
+        """
+
+    def __await__(self):
+        return self._setup().__await__()
+
+    @abstractmethod
+    async def _setup(self) -> Self:
+        return self
+
+    def _check_identity(self, request) -> bool:
+        validators = (
+            self.kind.module_id == request.header.module_index,
+            self.kind.port_id == request.header.port_index
+        )
+        return all(validators)
+
+    def __is_reservation(self, reserved_status: enums.ReservedStatus) -> bool:
+        return self.info.reservation == reserved_status
+
+    is_released = functools.partialmethod(__is_reservation, enums.ReservedStatus.RELEASED)
+    """
+    Check if port is released
+    """
+
+    is_reserved_by_me = functools.partialmethod(__is_reservation, enums.ReservedStatus.RESERVED_BY_YOU)
+    """
+    Check if port is released by me
+    """
+
+    is_reserved_by_others = functools.partialmethod(__is_reservation, enums.ReservedStatus.RESERVED_BY_OTHER)
+    """
+    Check if port is released by others
+    """
+
+    @property
+    @abstractmethod
+    def info(self) -> PortStateStorage:
+        """Module info"""
+        raise NotImplementedError()
+
+    on_reservation_change = functools.partialmethod(utils.on_event, P_RESERVATION)
+    """
+    Register a callback to the event that the port's reservation status changes.
+    """
+
+    on_receive_sync_change = functools.partialmethod(utils.on_event, P_RECEIVESYNC)
+    """
+    Register a callback to the event that the port's SYNC status changes.
+    """
+
+    on_reserved_by_change = functools.partialmethod(utils.on_event, P_RESERVEDBY)
+    """
+    Register a callback to the event that the port's reservation ownership changes.
+    """
+
+    on_interface_change = functools.partialmethod(utils.on_event, P_INTERFACE)
+    """
+    Register a callback to the event that the port's physical interface type changes.
+    """

xoa_driver/internals/hli_v1/ports/port_l23/bases/port_capture.py

@@ -0,0 +1,70 @@
+from typing import (
+    TYPE_CHECKING,
+    List,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P_CAPTURE,
+    PC_TRIGGER,
+    PC_KEEP,
+    PC_STATS,
+    PC_EXTRA,
+    PC_PACKET,
+)
+
+
+class ObtainCaptured:
+    """Obtain info of captured packets.
+    """
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, capture_pkt_idx: int) -> None:
+        self.extra = PC_EXTRA(conn, module_id, port_id, capture_pkt_idx)
+        """Obtains extra information about a captured packet on a L23 port.
+        
+        :type: PC_EXTRA
+        """
+
+        self.packet = PC_PACKET(conn, module_id, port_id, capture_pkt_idx)
+        """Obtains raw bytes of a captured packet on a L23 port.
+        
+        :type: PC_PACKET
+        """
+
+
+class PortCapture:
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.__conn = conn
+        self.__module_id = module_id
+        self.__port_id = port_id
+        self.state = P_CAPTURE(conn, module_id, port_id)
+        """L23 port traffic capture.
+        
+        :type: P_CAPTURE
+        """
+
+        self.trigger = PC_TRIGGER(conn, module_id, port_id)
+        """L23 port packet capture triggering criteria.
+        
+        :type: PC_TRIGGER
+        """
+
+        self.keep = PC_KEEP(conn, module_id, port_id)
+        """Keeping captured packets on a L23 port.
+        
+        :type: PC_KEEP
+        """
+
+        self.stats = PC_STATS(conn, module_id, port_id)
+        """L23 port's number of packets in the capture buffer.
+        
+        :type: PC_STATS
+        """
+
+    async def obtain_captured(self) -> List[ObtainCaptured]:
+        # TODO: check better title for this operation
+        stats = await self.stats.get()
+        return [
+            ObtainCaptured(self.__conn, self.__module_id, self.__port_id, idx)
+            for idx in range(stats.packets)
+        ]