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

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

@@ -0,0 +1,229 @@
+import functools
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P_FLASH,
+    P_SPEEDSELECTION,
+    P_SPEEDS_SUPPORTED,
+    P_UAT_MODE,
+    P_UAT_FLR,
+    P_STATUS,
+    P_TCVRSTATUS,
+    P_LOADMODE,
+    PP_FECMODE,
+    P_MACSEC_RX_ENABLE
+)
+from xoa_driver.internals.utils import attributes as utils
+from xoa_driver.internals.utils.indices import index_manager as idx_mgr
+from xoa_driver.internals.hli_v1.indices.streams.genuine_stream import GenuineStreamIdx
+from xoa_driver.internals.hli_v1.indices.filter.genuine_filter import GenuineFilterIdx
+from xoa_driver.internals.hli_v1.indices.port_dataset import PortDatasetIdx
+from xoa_driver.internals.state_storage import ports_state
+from xoa_driver.internals.hli_v1.indices.macsecscs.genuine_macsecsc import GenuineMacSecTxScIdx, GenuineMacSecRxScIdx
+
+from .port_l23 import (
+    BasePortL23,
+    Speed,
+    # TxConfiguration,
+)
+
+from .port_transceiver import PortTransceiver
+from .port_reception_statistics import GenuinePortReceptionStatistics
+from .port_transmission_statistics import GenuinePortTransmissionStatistics
+
+StreamIndices = idx_mgr.IndexManager[GenuineStreamIdx]
+FilterIndices = idx_mgr.IndexManager[GenuineFilterIdx]
+PortDatasetIndices = idx_mgr.IndexManager[PortDatasetIdx]
+MacSecTxScIndices = idx_mgr.IndexManager[GenuineMacSecTxScIdx]
+MacSecRxScIndices = idx_mgr.IndexManager[GenuineMacSecRxScIdx]
+
+class SpeedMode:
+    """L23 port's speed mode"""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.selection = P_SPEEDSELECTION(conn, module_id, port_id)
+        """L23 port speed mode selection.
+
+        :type: P_SPEEDSELECTION
+        """
+
+        self.supported = P_SPEEDS_SUPPORTED(conn, module_id, port_id)
+        """L23 port's supported speed modes.
+
+        :type: P_SPEEDS_SUPPORTED
+        """
+
+
+class GenuineSpeed(Speed):
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        super().__init__(conn, module_id, port_id)
+        self.mode = SpeedMode(conn, module_id, port_id)
+        """L23 port's speed mode."""
+
+
+class UnAvailableTime:
+    """UnAvailable Time"""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.mode = P_UAT_MODE(conn, module_id, port_id)
+        """L23 port's Unavailable Time mode.
+
+        :type: P_UAT_MODE
+        """
+
+        self.frame_loss_ratio = P_UAT_FLR(conn, module_id, port_id)
+        """L23 port's Frame Loss Ratio for UAT.
+
+        :type: P_UAT_FLR
+        """
+
+
+class PortStatistics:
+    """L23 port statistics"""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = GenuinePortReceptionStatistics(conn, module_id, port_id)
+        """L23 port's RX statistics."""
+
+        self.tx = GenuinePortTransmissionStatistics(conn, module_id, port_id)
+        """L23 port's TX statistics."""
+
+
+class BasePortL23Genuine(BasePortL23):
+    """L23 port basic configuration."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        super().__init__(conn, module_id, port_id)
+
+        self._local_states = ports_state.PortL23GenuineLocalState()
+
+        self.flash = P_FLASH(conn, module_id, port_id)
+        """L23 port flashes.
+
+        :type: P_FLASH
+        """
+
+        self.status = P_STATUS(conn, module_id, port_id)
+        """L23 port's received optical signal level'.
+
+        :type: P_STATUS
+        """
+
+        self.config_load_mode = P_LOADMODE(conn, module_id, port_id)
+        """Chimera Port loading mode.
+
+        :type: P_LOADMODE
+        """
+
+        self.tcvr_status = P_TCVRSTATUS(conn, module_id, port_id)
+        """L23 port transceiver status information.
+
+        :type: P_TCVRSTATUS
+        """
+
+        self.fec_mode = PP_FECMODE(conn, module_id, port_id)
+        """L23 port FEC mode.
+
+        :type: PP_FECMODE
+        """
+
+        self.speed = GenuineSpeed(conn, module_id, port_id)
+        """L23 port speed configuration.
+
+        :type: GenuineSpeed
+        """
+
+        self.uat = UnAvailableTime(conn, module_id, port_id)
+        """L23 port UnAvailable Time configuration.
+
+        :type: UnAvailableTime
+        """
+
+        self.transceiver = PortTransceiver(conn, module_id, port_id)
+        """L23 port transceiver configuration.
+
+        :type: PortTransceiver
+        """
+
+        self.statistics = PortStatistics(conn, module_id, port_id)
+        """L23 port statistics.
+
+        :type: PortStatistics
+        """
+
+        self.macsec_rx = P_MACSEC_RX_ENABLE(conn, module_id, port_id)
+        """L23 port MACSec RX enable.
+
+        :type: P_MACSEC_RX_ENABLE        
+        """
+
+        self.streams: StreamIndices = idx_mgr.IndexManager(
+            conn,
+            GenuineStreamIdx,
+            module_id,
+            port_id
+        )
+        """L23 port stream index manager.
+
+        :type: StreamIndices
+        """
+
+        self.filters: FilterIndices = idx_mgr.IndexManager(
+            conn,
+            GenuineFilterIdx,
+            module_id,
+            port_id
+        )
+        """L23 port filter index manager.
+
+        :type: FilterIndices
+        """
+
+        self.datasets: PortDatasetIndices = idx_mgr.IndexManager(
+            conn,
+            PortDatasetIdx,
+            module_id,
+            port_id
+        )
+        """L23 port histogram index manager.
+
+        :type: PortDatasetIndices
+        """
+
+        self.macsec_txscs: MacSecTxScIndices = idx_mgr.IndexManager(
+            conn,
+            GenuineMacSecTxScIdx,
+            module_id,
+            port_id
+        )
+        """L23 port MACSec TX SC index manager.
+
+        :type: MacSecTxScIndices
+        """
+
+        self.macsec_rxscs: MacSecRxScIndices = idx_mgr.IndexManager(
+            conn,
+            GenuineMacSecRxScIdx,
+            module_id,
+            port_id
+        )
+        """L23 port MACSec RX SC index manager.
+
+        :type: MacSecRxScIndices
+        """
+
+    @property
+    def info(self) -> ports_state.PortL23GenuineLocalState:
+        return self._local_states
+
+    async def _setup(self):
+        await self._local_states.initiate(self)
+        self._local_states.register_subscriptions(self)
+        return self
+
+    on_speed_selection_change = functools.partialmethod(utils.on_event, P_SPEEDSELECTION)
+    """Register a callback to the event that the port's speed mode changes."""
+
+    on_macsec_rx_enable_change = functools.partialmethod(utils.on_event, P_MACSEC_RX_ENABLE)
+    """Register a callback to the event that the port MACsec RX enable status changes."""

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

@@ -0,0 +1,231 @@
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+
+from xoa_driver.internals.commands import (
+    PR_TPLDJITTER,
+    PR_TOTAL,
+    PR_NOTPLD,
+    PR_EXTRA,
+    PR_TPLDS,
+    PR_TPLDTRAFFIC,
+    PR_TPLDERRORS,
+    PR_TPLDLATENCY,
+    PR_FILTER,
+    PR_CLEAR,
+    PR_PFCSTATS,
+    PR_TOTALEXT,
+    PR_NOTPLDEXT,
+    PR_TPLDTRAFFICEXT,
+    PR_FILTEREXT,
+    # genuine only
+    PR_CALIBRATE,
+    PR_UAT_STATUS,
+    PR_UAT_TIME,
+    P_MACSEC_RX_STATS,
+    P_MACSEC_RX_CLEAR
+
+)
+
+
+# region All Ports
+
+class PrsTPLD:
+    """L23 port's TPLD traffic statistics."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, tpld_idx: int) -> None:
+        self.traffic = PR_TPLDTRAFFIC(conn, module_id, port_id, tpld_idx)
+        """L23 port's statistics of traffic with TPLD.
+
+        :type: PR_TPLDTRAFFIC
+        """
+
+        self.traffic_ext = PR_TPLDTRAFFICEXT(conn, module_id, port_id, tpld_idx)
+        """L23 port's statistics of traffic with TPLD. (extended)
+        
+        :type: PR_TPLDTRAFFICEXT
+        """
+
+        self.errors = PR_TPLDERRORS(conn, module_id, port_id, tpld_idx)
+        """L23 port's error statistics of traffic with TPLD.
+
+        :type: PR_TPLDERRORS
+        """
+
+        self.latency = PR_TPLDLATENCY(conn, module_id, port_id, tpld_idx)
+        """L23 port's latency statistics of traffic with TPLD.
+
+        :type: PR_TPLDLATENCY
+        """
+
+        self.jitter = PR_TPLDJITTER(conn, module_id, port_id, tpld_idx)
+        """L23 port's jitter statistics of traffic with TPLD.
+
+        :type: PR_TPLDJITTER
+        """
+
+
+class PortReceptionStatistics:
+    """Port RX statistics"""
+
+    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.__tpld_ids = PR_TPLDS(conn, module_id, port_id)
+
+        self.total = PR_TOTAL(conn, module_id, port_id)
+        """L23 port's total traffic statistics.
+
+        :type: PR_TOTAL
+        """
+
+        self.total_ext = PR_TOTALEXT(conn, module_id, port_id)
+        """L23 port's total traffic statistics. (extended)
+        
+        :type: PR_TOTALEXT
+        """
+
+        self.no_tpld = PR_NOTPLD(conn, module_id, port_id)
+        """L23 port's statistics of traffic without TPLD.
+
+        :type: PR_NOTPLD
+        """
+
+        self.no_tpld_ext = PR_NOTPLDEXT(conn, module_id, port_id)
+        """L23 port's statistics of traffic without TPLD. (extended)
+        
+        :type: PR_NOTPLDEXT
+        """
+
+        self.extra = PR_EXTRA(conn, module_id, port_id)
+        """L23 port's extra traffic statistics.
+
+        :type: PR_EXTRA
+        """
+        self.pfc_stats = PR_PFCSTATS(conn, module_id, port_id)
+        """L23 port's statistics of received PFC packets.
+
+        :type: PR_PFCSTATS
+        """
+        self.clear = PR_CLEAR(conn, module_id, port_id)
+        """Clear all RX statistics on the L23 port.
+
+        :type: PR_CLEAR
+        """
+
+    def obtain_filter_statistics(self, filter: int) -> "PR_FILTER":
+        """Obtain L23 port filtered traffic statistics.
+
+        :param filter: index of the filter
+        :type filter: int
+        :return: filtered traffic statistics
+        :rtype: PR_FILTER
+        """
+
+        return PR_FILTER(
+            self.__conn,
+            self.__module_id,
+            self.__port_id,
+            filter
+        )
+
+    def obtain_filter_statistics_ext(self, filter: int) -> "PR_FILTEREXT":
+        """Obtain L23 port filtered traffic statistics. (extended)
+
+        :param filter: index of the filter
+        :type filter: int
+        :return: filtered traffic statistics
+        :rtype: PR_FILTEREXT
+        """
+
+        return PR_FILTEREXT(
+            self.__conn,
+            self.__module_id,
+            self.__port_id,
+            filter
+        )
+
+    def access_tpld(self, tpld_id: int) -> "PrsTPLD":
+        """Access a certain TPLD value on a L23 port.
+
+        :param tpld_id: TPLD value.
+        :type tpld_id: int
+        :return: L23 port's TPLD traffic statistics
+        :rtype: PrsTPLD
+        """
+        return PrsTPLD(self.__conn, self.__module_id, self.__port_id, tpld_id)
+
+    async def obtain_available_tplds(self) -> Dict[int, "PrsTPLD"]:
+        #TODO: need to check use case if this is enough, otherwise to extend by give possibility manually specify indices
+        tplds = await self.__tpld_ids.get()
+        return {
+            idx:
+            PrsTPLD(self.__conn, self.__module_id, self.__port_id, idx)
+            for idx in tplds.test_payload_identifiers
+        }
+
+
+# endregion
+
+# region Genuine Ports
+class GPrsUat():
+    """L23 port UAT info."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.status = PR_UAT_STATUS(conn, module_id, port_id)
+        """L23 port UAT status.
+
+        :type: PR_UAT_STATUS
+        """
+
+        self.time = PR_UAT_TIME(conn, module_id, port_id)
+        """L23 port number of unavailable seconds.
+
+        :type: PR_UAT_TIME
+        """
+
+
+class MACSecRxStats:
+    """MACSec RX SC Statistics"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+
+        self.total = P_MACSEC_RX_STATS(conn, module_id, port_id)
+        """Port's total MACsec RX statistics
+
+        :type: P_MACSEC_RX_STATS
+        """
+
+        self.clear = P_MACSEC_RX_CLEAR(conn, module_id, port_id)
+        """Clear Port's MACsec RX statistics
+
+        :type: P_MACSEC_RX_CLEAR
+        """
+
+
+class GenuinePortReceptionStatistics(PortReceptionStatistics):
+    """L23 port RX statistics."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        super().__init__(conn, module_id, port_id)
+        self.calibrate = PR_CALIBRATE(conn, module_id, port_id)
+        """L23 port calibration of latency for received packets.
+
+        :type: PR_CALIBRATE
+        """
+
+        self.uat = GPrsUat(conn, module_id, port_id)
+        """L23 port UAT info.
+
+        :type: GPrsUat
+        """
+
+        self.macsec = MACSecRxStats(conn, module_id, port_id)
+        """L23 port's MACsec RX statistics.
+        """
+
+# endregion

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

@@ -0,0 +1,117 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    PX_RW,
+    PX_MII,
+    PX_TEMPERATURE,
+    PX_RW_SEQ,
+    PX_I2C_CONFIG,
+    PX_RW_SEQ_BANK,
+)
+
+
+class PortTransceiver:
+    """L23 port transceiver."""
+
+    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.i2c_config = PX_I2C_CONFIG(conn, module_id, port_id)
+        """Access speed on a transceiver.
+        :type: PX_I2C_CONFIG
+        """
+
+    def access_temperature(self):
+        """Transceiver temperature in Celsius.
+
+        :return: Transceiver temperature integral and decimal parts
+        :rtype: PX_TEMPERATURE
+        """
+
+        return PX_TEMPERATURE(
+            self.__conn,
+            self.__module_id,
+            self.__port_id,
+        )
+
+    def access_rw(self, page_address: int, register_address: int) -> "PX_RW":
+        """Access to register interface by the transceiver.
+
+        :param page_address: page address
+        :type page_address: int
+        :param register_address: register address
+        :type register_address: int
+        :return: transceiver register values
+        :rtype: PX_RW
+        """
+
+        return PX_RW(
+            self.__conn,
+            self.__module_id,
+            self.__port_id,
+            page_address,
+            register_address
+        )
+
+    def access_mii(self, register_address: int) -> "PX_MII":
+        """Access to the register interface supported by the media-independent interface (MII) transceiver.
+
+        :param register_address: register address
+        :type register_address: int
+        :return: register values
+        :rtype: PX_MII
+        """
+        return PX_MII(
+            self.__conn,
+            self.__module_id,
+            self.__port_id,
+            register_address
+        )
+
+    def access_rw_seq(self, page_address: int, register_address: int, byte_count: int) -> "PX_RW_SEQ":
+        """Sequential read/write a number of bytes to the register interface supported by the media-independent interface (MII) transceiver.
+
+        :param page_address: page address (0-255)
+        :type page_address: int
+        :param register_address: register address (0-255)
+        :type register_address: int
+        :param byte_count: the number of bytes to read/write
+        :type byte_count: int
+        :return: transceiver register values
+        :rtype: PX_RW_SEQ
+        """
+        return PX_RW_SEQ(
+            self.__conn,
+            self.__module_id,
+            self.__port_id,
+            page_address,
+            register_address,
+            byte_count
+        )
+    
+    def access_rw_seq_bank(self, bank_address: int, page_address: int, register_address: int, byte_count: int) -> "PX_RW_SEQ_BANK":
+        """Sequential read/write a number of bytes to the register interface supported by the media-independent interface (MII) transceiver.
+
+        :param bank_address: bank address (0-255)
+        :type bank_address: int
+        :param page_address: page address (0-255)
+        :type page_address: int
+        :param register_address: register address (0-255)
+        :type register_address: int
+        :param byte_count: the number of bytes to read/write
+        :type byte_count: int
+        :return: transceiver register values
+        :rtype: PX_RW_SEQ_BANK
+        """
+        return PX_RW_SEQ_BANK(
+            self.__conn,
+            self.__module_id,
+            self.__port_id,
+            bank_address,
+            page_address,
+            register_address,
+            byte_count
+        )

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

@@ -0,0 +1,131 @@
+from typing import (
+    TYPE_CHECKING,
+    Union,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+    from xoa_driver.internals.hli_v1.indices.streams.genuine_stream import GenuineStreamIdx
+from xoa_driver.internals.commands import (
+    PT_TOTAL,
+    PT_NOTPLD,
+    PT_STREAM,
+    PT_CLEAR,
+    PT_EXTRA,
+    PT_TOTALEXT,
+    PT_NOTPLDEXT,
+    PT_STREAMEXT,
+    P_MACSEC_TX_STATS,
+    P_MACSEC_TX_CLEAR,
+)
+
+# region All Ports
+
+class PortTransmissionStatistics:
+    """L23 port TX statistics"""
+
+    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.total = PT_TOTAL(conn, module_id, port_id)
+        """All TX statistics on the L23 port.
+        
+        :type: PT_TOTAL
+        """
+
+        self.total_ext = PT_TOTALEXT(conn, module_id, port_id)
+        """All TX statistics on the L23 port. (extended)
+        
+        :type: PT_TOTALEXT
+        """
+
+        self.extra = PT_EXTRA(conn, module_id, port_id)
+        """Extra TX statistics on the L23 port.
+        
+        :type: PT_EXTRA
+        """
+
+        self.no_tpld = PT_NOTPLD(conn, module_id, port_id)
+        """TX statistics of packets without TPLD on the L23 port.
+        
+        :type: PT_NOTPLD
+        """
+
+        self.no_tpld_ext = PT_NOTPLDEXT(conn, module_id, port_id)
+        """TX statistics of packets without TPLD on the L23 port. (extended)
+        
+        :type: PT_NOTPLDEXT
+        """
+
+        self.clear = PT_CLEAR(conn, module_id, port_id)
+        """Clear TX statistics on the L23 port.
+        
+        :type: PT_CLEAR
+        """
+
+    def obtain_from_stream(self, stream: Union[int, "GenuineStreamIdx"]) -> "PT_STREAM":
+        """Obtain statistics of packets of a specific stream on a L23 port.
+
+        :param stream: stream object
+        :type stream: Union[int, "GenuineStreamIdx"]
+        :return: statistics of packets of a specific stream on a L23 port
+        :rtype: PT_STREAM
+        """
+
+        stream_idx = stream if isinstance(stream, int) else stream.kind.index_id
+        return PT_STREAM(
+            self.__conn,
+            self.__module_id,
+            self.__port_id,
+            stream_idx
+        )
+
+    def obtain_from_stream_ext(self, stream: Union[int, "GenuineStreamIdx"]) -> "PT_STREAMEXT":
+        """Obtain statistics of packets of a specific stream on a L23 port. (extended)
+
+        :param stream: stream object
+        :type stream: Union[int, "GenuineStreamIdx"]
+        :return: statistics of packets of a specific stream on a L23 port
+        :rtype: PT_STREAMEXT
+        """
+
+        stream_idx = stream if isinstance(stream, int) else stream.kind.index_id
+        return PT_STREAMEXT(
+            self.__conn,
+            self.__module_id,
+            self.__port_id,
+            stream_idx
+        )
+
+# endregion
+
+# region Genuine Ports
+
+class MACSecTxStats:
+    """MACSec TX SC Statistics"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+
+        self.total = P_MACSEC_TX_STATS(conn, module_id, port_id)
+        """Port's total MACsec TX statistics
+
+        :type: P_MACSEC_TX_STATS
+        """
+
+        self.clear = P_MACSEC_TX_CLEAR(conn, module_id, port_id)
+        """Clear Port's MACsec TX statistics
+
+        :type: P_MACSEC_TX_CLEAR
+        """
+
+
+class GenuinePortTransmissionStatistics(PortTransmissionStatistics):
+    """L23 port RX statistics."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        super().__init__(conn, module_id, port_id)
+
+        self.macsec = MACSecTxStats(conn, module_id, port_id)
+        """L23 port's MACsec TX statistics.
+        """
+
+# endregion