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

xoa_driver/internals/hli_v1/ports/port_l23/chimera/pe_distribution.py

@@ -0,0 +1,174 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands.enums import ImpairmentTypeIndex
+from xoa_driver.internals.commands import (
+    PED_SCHEDULE,
+    PED_ONESHOTSTATUS,
+    PED_OFF,
+    PED_FIXED,
+    PED_RANDOM,
+    PED_BER,
+    PED_FIXEDBURST,
+    PED_RANDOMBURST,
+    PED_GE,
+    PED_UNI,
+    PED_GAUSS,
+    PED_POISSON,
+    PED_GAMMA,
+    PED_CUST,
+    PED_CONST,
+    PED_ACCBURST,
+    PED_STEP,
+    PED_ENABLE,
+)
+
+
+class ImpairmentDistributionConfig:
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, impairment_type_index: "ImpairmentTypeIndex") -> None:
+        self.enable = PED_ENABLE(conn, module_id, port_id, flow_index, impairment_type_index)
+        """Impairment distribution control.
+
+        :type: PED_ENABLE
+        """
+
+        self.schedule = PED_SCHEDULE(conn, module_id, port_id, flow_index, impairment_type_index)
+        """Impairment scheduling configuration.
+
+        :type: PED_SCHEDULE
+        """
+
+        self.one_shot_status = PED_ONESHOTSTATUS(conn, module_id, port_id, flow_index, impairment_type_index)
+        """One-shot status.
+
+        :type: PED_ONESHOTSTATUS
+        """
+
+        self.off = PED_OFF(conn, module_id, port_id, flow_index, impairment_type_index)
+        """Impairments Distribution to OFF.
+
+        :type: PED_OFF
+        """
+
+        self.fixed_rate = PED_FIXED(conn, module_id, port_id, flow_index, impairment_type_index)
+        """Fixed Rate distribution configuration.
+
+        :type: PED_FIXED
+        """
+
+        self.random_rate = PED_RANDOM(conn, module_id, port_id, flow_index, impairment_type_index)
+        """Random Rate distribution configuration.
+
+        :type: PED_RANDOM
+        """
+
+        self.bit_error_rate = PED_BER(conn, module_id, port_id, flow_index, impairment_type_index)
+        """Bit Error Rate distribution configuration.
+
+        :type: PED_BER
+        """
+
+        self.random_burst = PED_RANDOMBURST(conn, module_id, port_id, flow_index, impairment_type_index)
+        """Random Burst configuration.
+
+        :type: PED_RANDOMBURST
+        """
+
+        self.ge = PED_GE(conn, module_id, port_id, flow_index, impairment_type_index)
+        """Gilbert-Elliot distribution configuration.
+
+        :type: PED_GE
+        """
+
+        self.uniform = PED_UNI(conn, module_id, port_id, flow_index, impairment_type_index)
+        """Uniform distribution configuration.
+
+        :type: PED_UNI
+        """
+
+        self.gaussian = PED_GAUSS(conn, module_id, port_id, flow_index, impairment_type_index)
+        """Gaussian distribution configuration.
+
+        :type: PED_GAUSS
+        """
+
+        self.poisson = PED_POISSON(conn, module_id, port_id, flow_index, impairment_type_index)
+        """Poisson distribution configuration.
+
+        :type: PED_POISSON
+        """
+
+        self.gamma = PED_GAMMA(conn, module_id, port_id, flow_index, impairment_type_index)
+        """Gamma distribution configuration.
+
+        :type: PED_GAMMA
+        """
+
+        self.custom = PED_CUST(conn, module_id, port_id, flow_index, impairment_type_index)
+        """Associate a custom distribution to a flow and impairment type.
+
+        :type: PED_CUST
+        """
+
+        self.constant_delay = PED_CONST(conn, module_id, port_id, flow_index, impairment_type_index)
+        """Constant Delay distribution configuration.
+
+        :type: PED_CONST
+        """
+
+        self.accumulate_and_burst = PED_ACCBURST(conn, module_id, port_id, flow_index, impairment_type_index)
+        """Accumulate & Burst distribution configuration.
+
+        :type: PED_ACCBURST
+        """
+
+        self.step = PED_STEP(conn, module_id, port_id, flow_index, impairment_type_index)
+        """Step distribution configuration.
+
+        :type: PED_STEP
+        """
+
+        self.fixed_burst = PED_FIXEDBURST(conn, module_id, port_id, flow_index, impairment_type_index)
+        """Fixed Burst distribution configuration.
+
+        :type: PED_FIXEDBURST
+        """
+
+
+class ImpairmentTypeDistribution:
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int) -> None:
+        self.drop_type_config = ImpairmentDistributionConfig(conn, module_id, port_id, flow_index, ImpairmentTypeIndex.DROP)
+        """Impairment distribution configuration of impairment type Drop.
+
+        :type: ImpairmentDistributionConfig
+        """
+
+        self.misorder_type_config = ImpairmentDistributionConfig(conn, module_id, port_id, flow_index, ImpairmentTypeIndex.MISORDER)
+        """Impairment distribution configuration of impairment type Misorder."""
+
+        self.latency_jitter_type_config = ImpairmentDistributionConfig(conn, module_id, port_id, flow_index, ImpairmentTypeIndex.LATENCYJITTER)
+        """Impairment distribution configuration of impairment type Delay Jitter."""
+
+        self.duplication_type_config = ImpairmentDistributionConfig(conn, module_id, port_id, flow_index, ImpairmentTypeIndex.DUPLICATION)
+        """Impairment distribution configuration of impairment type Duplication.
+
+        :type: ImpairmentDistributionConfig
+        """
+
+        self.corruption_type_config = ImpairmentDistributionConfig(conn, module_id, port_id, flow_index, ImpairmentTypeIndex.CORRUPTION)
+        """Impairment distribution configuration of impairment type Corruption.
+
+        :type: ImpairmentDistributionConfig
+        """
+
+        self.policer_type_config = ImpairmentDistributionConfig(conn, module_id, port_id, flow_index, ImpairmentTypeIndex.POLICER)
+        """Impairment distribution configuration of impairment type Policer.
+
+        :type: ImpairmentDistributionConfig
+        """
+
+        self.shaper_type_config = ImpairmentDistributionConfig(conn, module_id, port_id, flow_index, ImpairmentTypeIndex.SHAPER)
+        """Impairment distribution configuration of impairment type Shaper.
+
+        :type: ImpairmentDistributionConfig
+        """

xoa_driver/internals/hli_v1/ports/port_l23/chimera/port_chimera.py

@@ -0,0 +1,119 @@
+import asyncio
+import functools
+from typing import TYPE_CHECKING
+
+from xoa_driver.internals.commands import (
+    P_CAPABILITIES,
+    P_INTERFACE,
+    P_STATUS,
+    P_TXENABLE,
+    P_LOADMODE,
+    P_EMULATE,
+    P_CAPABILITIES_EXT,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+
+from xoa_driver.internals.hli_v1.ports import base_port
+from xoa_driver.internals.utils import attributes as utils
+from xoa_driver.internals.state_storage import ports_state
+from ..pcs_pma_ijkl_chimera import PcsPma
+from .pe_custom_distribution import CustomDistributions
+from .port_emulation import ChimeraPE
+
+
+class PortChimera(base_port.BasePort[ports_state.PortChimeraLocalState]):
+    """Chimera port for traffic impairment."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        super().__init__(conn, module_id, port_id)
+        self.capabilities = P_CAPABILITIES(conn, module_id, port_id)
+        """Chimera port capabilities.
+
+        :type: P_CAPABILITIES
+        """
+
+        self.capabilities_ext = P_CAPABILITIES_EXT(conn, module_id, port_id)
+        """Chimera port capabilities ext.
+
+        :type: P_CAPABILITIES_EXT
+        """
+
+        self.interface = P_INTERFACE(conn, module_id, port_id)
+        """Physical interface type of the Chimera port.
+
+        :type: P_INTERFACE
+        """
+
+        self.status = P_STATUS(conn, module_id, port_id)
+        """Chimera port's received optical signal level'.
+
+        :type: P_STATUS
+        """
+
+        self.tx_enable = P_TXENABLE(conn, module_id, port_id)
+        """Enabling Chimera port TX.
+
+        :type: P_TXENABLE
+        """
+
+        self.load_mode = P_LOADMODE(conn, module_id, port_id)
+        """Load mode of the Chimera port.
+
+        :type: P_LOADMODE
+        """
+
+        self.emulation = ChimeraPE(self._conn, *self.kind)
+        """Chimera Port Emulation """
+
+        self.emulate = P_EMULATE(conn, module_id, port_id)
+        """Chimera port emulation control.
+
+        :type: P_EMULATE
+        """
+
+        self.custom_distributions = CustomDistributions(conn, module_id, port_id)
+        """Custom distributions."""
+
+        self.pcs_pma = PcsPma(conn, self)
+        """"PCS/PMA settings."""
+
+        self._local_states = ports_state.PortChimeraLocalState()
+        """Local states of the Chimera port."""
+
+    @property
+    def info(self) -> ports_state.PortChimeraLocalState:
+        return self._local_states
+
+    async def _setup(self):
+        await asyncio.gather(
+            self._local_states.initiate(self),
+            self.custom_distributions.server_sync(),
+            self.emulation
+        )
+        self._local_states.register_subscriptions(self)
+        return self
+
+    on_interface_change = functools.partialmethod(utils.on_event, P_INTERFACE)
+    """Register a callback to the event that the port's interface type changes."""
+
+    on_emulate_change = functools.partialmethod(utils.on_event, P_EMULATE)
+    """Register a callback to the event that the port's emulation state changes."""
+
+
+class PChi100G5S2P(PortChimera):
+    """Impairment port on Chi-100G-5S-2P module.
+    """
+    ...
+
+
+class PChi100G5S2P_b(PortChimera):
+    """Impairment port on Chi-100G-5S-2P[b] module.
+    """
+    ...
+
+
+class PChi40G2S2P(PortChimera):
+    """Impairment port on Chi-40G-2S-2P module.
+    """
+    ...

xoa_driver/internals/hli_v1/ports/port_l23/chimera/port_emulation.py

@@ -0,0 +1,244 @@
+from typing import (
+    TYPE_CHECKING,
+    Tuple,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+
+from xoa_driver.internals.commands import (
+    PE_FCSDROP,
+    PE_TPLDMODE,
+    PE_COMMENT,
+    PE_INDICES,
+    PE_LATENCYRANGE,
+    PE_CORRUPT,
+    PE_MISORDER,
+    PE_BANDPOLICER,
+    PE_BANDSHAPER,
+    PE_DROPTOTAL,
+    PE_LATENCYTOTAL,
+    PE_DUPTOTAL,
+    PE_MISTOTAL,
+    PE_CORTOTAL,
+    PE_JITTERTOTAL,
+    PE_CLEAR,
+    PE_FLOWDROPTOTAL,
+    PE_FLOWLATENCYTOTAL,
+    PE_FLOWDUPTOTAL,
+    PE_FLOWMISTOTAL,
+    PE_FLOWCORTOTAL,
+    PE_FLOWJITTERTOTAL,
+    PE_FLOWCLEAR,
+)
+
+from .reception_statistics import ReceptionStatistics
+from .transmission_statistics import TransmissionStatistics
+from .pe_distribution import ImpairmentTypeDistribution
+from .filter_definition import (
+    shadow,
+    working,
+)
+
+
+class CTotalFlow:
+    """Total flow statistics."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int) -> None:
+        self.drop_packets = PE_FLOWDROPTOTAL(conn, module_id, port_id, flow_index)
+        """Statistics of all packets dropped in a flow.
+
+        :type: PE_FLOWDROPTOTAL
+        """
+
+        self.latency_packets = PE_FLOWLATENCYTOTAL(conn, module_id, port_id, flow_index)
+        """Statistics of all packets delayed in a flow.
+
+        :type: PE_FLOWLATENCYTOTAL
+        """
+
+        self.duplicated_packets = PE_FLOWDUPTOTAL(conn, module_id, port_id, flow_index)
+        """Statistics of all packets duplicate in a flow.
+
+        :type: PE_FLOWDUPTOTAL
+        """
+
+        self.mis_ordered_packets = PE_FLOWMISTOTAL(conn, module_id, port_id, flow_index)
+        """Statistics of all packets misordered in a flow.
+
+        :type: PE_FLOWMISTOTAL
+        """
+
+        self.corrupted_packets = PE_FLOWCORTOTAL(conn, module_id, port_id, flow_index)
+        """Statistics of all packets corrupted in a flow.
+
+        :type: PE_FLOWCORTOTAL
+        """
+
+        self.jittered_packets = PE_FLOWJITTERTOTAL(conn, module_id, port_id, flow_index)
+        """Statistics of all packets jittered in a flow.
+
+        :type: PE_FLOWJITTERTOTAL
+        """
+
+
+class StatisticsTotals:
+    """Total port statistics."""
+
+    def __init__(self, conn, module_id, port_id) -> None:
+        self.drop = PE_DROPTOTAL(conn, module_id, port_id)
+        """Statistics of all packets dropped on the port.
+
+        :type: PE_DROPTOTAL
+        """
+
+        self.latency = PE_LATENCYTOTAL(conn, module_id, port_id)
+        """Statistics of all packets delayed on the port.
+
+        :type: PE_LATENCYTOTAL
+        """
+
+        self.duplicated = PE_DUPTOTAL(conn, module_id, port_id)
+        """Statistics of all packets duplicated on the port.
+
+        :type: PE_DUPTOTAL
+        """
+
+        self.mis_ordered = PE_MISTOTAL(conn, module_id, port_id)
+        """Statistics of all packets mirordered on the port.
+
+        :type: PE_MISTOTAL
+        """
+
+        self.corrupted = PE_CORTOTAL(conn, module_id, port_id)
+        """Statistics of all packets corrupted on the port.
+
+        :type: PE_CORTOTAL
+        """
+
+        self.jittered = PE_JITTERTOTAL(conn, module_id, port_id)
+        """Statistics of all packets jittered on the port.
+
+        :type: PE_JITTERTOTAL
+        """
+
+
+class CFlowStatistics:
+    """Per flow statistics."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int) -> None:
+        self.rx = ReceptionStatistics(conn, module_id, port_id, flow_index)
+        """RX statistics."""
+
+        self.tx = TransmissionStatistics(conn, module_id, port_id, flow_index)
+        """TX statistics."""
+
+        self.total = CTotalFlow(conn, module_id, port_id, flow_index)
+        """Total flow statistics."""
+
+        self.clear = PE_FLOWCLEAR(conn, module_id, port_id, flow_index)
+        """Clear the impairment statistics on a flow.
+
+        :type: PE_FLOWCLEAR
+        """
+
+
+class CBandwidth:
+    """Bandwidth configuration."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int) -> None:
+        self.policer = PE_BANDPOLICER(conn, module_id, port_id, flow_index)
+        """Bandwidth policer configuration.
+
+        :type: PE_BANDPOLICER
+        """
+
+        self.shaper = PE_BANDSHAPER(conn, module_id, port_id, flow_index)
+        """Bandwidth shaper configuration.
+
+        :type: PE_BANDSHAPER
+        """
+
+
+class CFlow:
+    """Flow settings."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int) -> None:
+        self.comment = PE_COMMENT(conn, module_id, port_id, flow_index)
+        """Flow description.
+
+        :type: PE_COMMENT
+        """
+
+        self.latency_range = PE_LATENCYRANGE(conn, module_id, port_id, flow_index)
+        """Flow latency range.
+
+        :type: PE_LATENCYRANGE
+        """
+
+        self.corruption = PE_CORRUPT(conn, module_id, port_id, flow_index)
+        """Corruption type.
+
+        :type: PE_CORRUPT
+        """
+
+        self.misordering = PE_MISORDER(conn, module_id, port_id, flow_index)
+        """Misordering depth
+
+        :type: PE_MISORDER
+        """
+
+        self.bandwidth_control = CBandwidth(conn, module_id, port_id, flow_index)
+        """Bandwidth configuration."""
+
+        self.statistics = CFlowStatistics(conn, module_id, port_id, flow_index)
+        """Flow statistics."""
+
+        self.impairment_distribution = ImpairmentTypeDistribution(conn, module_id, port_id, flow_index)
+        """Impairment type's distribution."""
+
+        self.shadow_filter = shadow.FilterDefinitionShadow(conn, module_id, port_id, flow_index)
+        """Shadow copy."""
+
+        self.working_filter = working.FilterDefinitionWorking(conn, module_id, port_id, flow_index)
+        """Working copy."""
+
+
+class ChimeraPE:
+    """Port Emulation"""
+
+    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.drop_fcs_errors = PE_FCSDROP(conn, module_id, port_id)
+        """Action on FCS errors.
+
+        :type: PE_FCSDROP
+        """
+
+        self.clear = PE_CLEAR(conn, module_id, port_id)
+        """Clear impairment statistics.
+
+        :type: PE_CLEAR
+        """
+
+        self.statistics = StatisticsTotals(conn, module_id, port_id)
+        """Total port statistics."""
+
+        self.tpld_mode = PE_TPLDMODE(conn, module_id, port_id)
+        """TPLD mode.
+
+        :type: PE_TPLDMODE
+        """
+
+        self.flows: Tuple["CFlow", ...] = tuple()
+
+    def __await__(self):
+        return self._setup().__await__()
+
+    async def _setup(self) -> None:
+        indices = await PE_INDICES(self._conn, self.module_id, self.port_id).get()
+        self.flows = tuple(
+            CFlow(self._conn, self.module_id, self.port_id, idx)
+            for idx in indices.to_tuple()
+        )

xoa_driver/internals/hli_v1/ports/port_l23/chimera/reception_statistics.py

@@ -0,0 +1,24 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    PR_FLOWTOTAL,
+    PR_FLOWCLEAR,
+)
+
+
+class ReceptionStatistics:
+    """Chimera RX statistics."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int) -> None:
+        self.total = PR_FLOWTOTAL(conn, module_id, port_id, flow_index)
+        """RX statistics of a flow.
+
+        :type: PR_FLOWTOTAL
+        """
+
+        self.clear = PR_FLOWCLEAR(conn, module_id, port_id, flow_index)
+        """Clear RX statistics of a flow.
+
+        :type: PR_FLOWCLEAR
+        """

xoa_driver/internals/hli_v1/ports/port_l23/chimera/transmission_statistics.py

@@ -0,0 +1,24 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    PT_FLOWTOTAL,
+    PT_FLOWCLEAR,
+)
+
+
+class TransmissionStatistics:
+    """Chimera TX statistics."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int) -> None:
+        self.total = PT_FLOWTOTAL(conn, module_id, port_id, flow_index)
+        """TX statistics of a flow.
+        
+        :type: PT_FLOWTOTAL
+        """
+
+        self.clear = PT_FLOWCLEAR(conn, module_id, port_id, flow_index)
+        """Clear TX statistics of a flow.
+        
+        :type: PT_FLOWCLEAR
+        """

xoa_driver/internals/hli_v1/ports/port_l23/family_combi.py

@@ -0,0 +1,37 @@
+from typing import TYPE_CHECKING
+from xoa_driver.internals.commands import P_AUTONEGSELECTION
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+
+from .bases.port_l23_genuine import BasePortL23Genuine
+from . import family_f
+
+
+class POdin1G4S4PCombi(BasePortL23Genuine):
+    """L23 ports that supports MDI/MDIX and """
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        super().__init__(conn, module_id, port_id)
+
+        self.autoneg_selection = P_AUTONEGSELECTION(conn, module_id, port_id)
+        """L23 port's auto-negotiation selection.
+        
+        :type: P_AUTONEGSELECTION`
+        """
+
+
+class POdin1G4S4PCombi_b(POdin1G4S4PCombi):
+    """L23 port on Odin-1G-4S-2P-Combi_b module.
+    """
+    ...
+
+
+class POdin10G4S2PCombi(family_f.FamilyF):
+    """L23 port on Odin-10G-4S-2P-Combi module.
+    """
+    ...
+
+
+class POdin10G4S2PCombi_b(family_f.FamilyF):
+    """L23 port on Odin-10G-4S-2P-Combi_b module.
+    """
+    ...

xoa_driver/internals/hli_v1/ports/port_l23/family_d.py

@@ -0,0 +1,51 @@
+from typing import TYPE_CHECKING
+from xoa_driver.internals.commands import (
+    P_MDIXMODE,
+    P_AUTONEGSELECTION,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+
+from .bases.port_l23_genuine import BasePortL23Genuine
+
+
+class FamilyD(BasePortL23Genuine):
+    """L23 ports that supports MDI/MDIX and """
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        super().__init__(conn, module_id, port_id)
+        self.mdix_mode = P_MDIXMODE(conn, module_id, port_id)
+        """L23 port's MDI/MDIX mode.
+        
+        :type: P_MDIXMODE
+        """
+
+        self.autoneg_selection = P_AUTONEGSELECTION(conn, module_id, port_id)
+        """L23 port's auto-negotiation selection.
+        
+        :type: P_AUTONEGSELECTION
+        """
+
+
+class POdin1G3S6P(FamilyD):
+    """L23 port on Odin-1G-3S-6P module.
+    """
+    ...
+
+
+class POdin1G3S6P_b(FamilyD):
+    """L23 port on Odin-1G-3S-6P[b] module.
+    """
+    ...
+
+
+class POdin1G3S6PE(FamilyD):
+    """L23 port on Odin-1G-3S-6P-E module.
+    """
+    ...
+
+
+class POdin1G3S2PT(FamilyD):
+    """L23 port on Odin-1G-3S-2P-T module.
+    """
+    ...