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

xoa_driver/internals/hli_v2/ports/port_l23/chimera/filter_definition/shadow.py

@@ -1,99 +0,0 @@
-from typing import (
-    TYPE_CHECKING,
-    Dict,
-    Type,
-    Union
-)
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-from xoa_driver.internals.commands.enums import (
-    FilterType,
-    ProtocolOption,
-    FilterMode,
-)
-from xoa_driver.internals.commands import (
-    PEF_INIT,
-    PEF_APPLY,
-    PEF_ENABLE,
-    PEF_PROTOCOL,
-    PEF_MODE,
-    PEF_CANCEL,
-)
-from . import general
-
-
-class ModeExtendedS(general.ModeExtended):
-    async def use_segments(self, *segments: ProtocolOption) -> None:
-        segments_payload = [
-            ProtocolOption.ETHERNET,
-            *segments
-        ]
-        await PEF_PROTOCOL(
-            self._conn,
-            self._module_id,
-            self._port_id,
-            self._flow_index,
-            self._filter_type
-        ).set(segments_payload)
-
-
-class FilterDefinitionShadow:
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int) -> None:
-        self._conn = conn
-        self._module_id = module_id
-        self._port_id = port_id
-        self._flow_index = flow_index
-        self._filter_type = FilterType.SHADOW
-
-        self.initiating = PEF_INIT(conn, module_id, port_id, flow_index)
-        """Preparing filter definition.
-        Representation of PEF_INIT
-        """
-        self.apply = PEF_APPLY(conn, module_id, port_id, flow_index)
-        """Apply filter definition.
-        Representation of PEF_APPLY
-        """
-        self.enable = PEF_ENABLE(conn, module_id, port_id, flow_index, self._filter_type)
-        """Enabling the filter.
-        Representation of PEF_ENABLE
-        """
-        self.cancel = PEF_CANCEL(conn, module_id, port_id, flow_index)
-        """Cancel changes made to Shadow and restores them to the ones in Working.
-        Representation of PEF_CANCEL
-        """
-        # self.mode = PEF_MODE(conn, module_id, port_id, flow_index, self._filter_type)
-        # """Filter mode.
-        # Representation of PEF_MODE`
-        # """
-
-    async def get_mode(self) -> Union[general.ModeBasic, ModeExtendedS]:
-        mode_types: Dict[FilterMode, Type[Union[general.ModeBasic, ModeExtendedS]]] = {
-            FilterMode.BASIC: general.ModeBasic,
-            FilterMode.EXTENDED: ModeExtendedS,
-        }
-        return await general.get_mode(
-            self._conn,
-            self._module_id,
-            self._port_id,
-            self._flow_index,
-            self._filter_type,
-            mode_types
-        )
-
-    async def use_basic_mode(self) -> None:
-        await PEF_MODE(
-            self._conn,
-            self._module_id,
-            self._port_id,
-            self._flow_index,
-            self._filter_type,
-        ).set_basic()
-
-    async def use_extended_mode(self) -> None:
-        await PEF_MODE(
-            self._conn,
-            self._module_id,
-            self._port_id,
-            self._flow_index,
-            self._filter_type,
-        ).set_extended()

xoa_driver/internals/hli_v2/ports/port_l23/chimera/filter_definition/working.py

@@ -1,36 +0,0 @@
-from typing import (
-    Dict,
-    Type,
-    Union,
-    TYPE_CHECKING
-)
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-from xoa_driver.internals.commands.enums import (
-    FilterType,
-    FilterMode,
-)
-from . import general
-
-
-class FilterDefinitionWorking:
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int) -> None:
-        self._conn = conn
-        self._module_id = module_id
-        self._port_id = port_id
-        self._flow_index = flow_index
-        self._filter_type = FilterType.WORKING
-
-    async def get_mode(self) -> Union[general.ModeBasic, general.ModeExtended]:
-        mode_types: Dict[FilterMode, Type[Union[general.ModeBasic, general.ModeExtended]]] = {
-            FilterMode.BASIC: general.ModeBasic,
-            FilterMode.EXTENDED: general.ModeExtended,
-        }
-        return await general.get_mode(
-            self._conn,
-            self._module_id,
-            self._port_id,
-            self._flow_index,
-            self._filter_type,
-            mode_types
-        )

xoa_driver/internals/hli_v2/ports/port_l23/chimera/pe_custom_distribution.py

@@ -1,116 +0,0 @@
-from typing import (
-    TYPE_CHECKING,
-    Dict,
-    List,
-)
-from collections import UserDict
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-from xoa_driver.internals.commands import (
-    PEC_INDICES,
-    PEC_VAL,
-    PEC_COMMENT,
-    PEC_DELETE,
-    PEC_DISTTYPE,
-)
-
-from xoa_driver.internals.utils.indices import observer
-from xoa_driver.enums import OnOff
-
-
-class CustomDistribution:
-    """Custom distribution"""
-
-    def __init__(self, observer: "observer.IndicesObserver", conn: "itf.IConnection", module_id: int, port_id: int, custom_distribution_index: int) -> None:
-        self.__observer = observer
-        self.__conn = conn
-        self.__module_id = module_id
-        self.__port_id = port_id
-        self.custom_distribution_index = custom_distribution_index
-        self.definition = PEC_VAL(conn, module_id, port_id, custom_distribution_index)
-        """Custom distribution definition.
-        Representation of PEC_VAL
-        """
-
-        self.comment = PEC_COMMENT(conn, module_id, port_id, custom_distribution_index)
-        """Custom distribution description.
-        Representation of PEC_COMMENT
-        """
-
-        self.type = PEC_DISTTYPE(conn, module_id, port_id, custom_distribution_index)
-        """Custom distribution type.
-        Representation of PEC_DISTTYPE
-        """
-
-    async def delete(self) -> None:
-        """
-        Deleting an existing Custom Distribution
-        """
-
-        await PEC_DELETE(
-            self.__conn,
-            self.__module_id,
-            self.__port_id,
-            self.custom_distribution_index
-        ).set()
-        self.__observer.notify(observer.IndexEvents.DEL, self)
-
-
-class CustomDistributions(UserDict):
-    """Custom distributions"""
-
-    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.data: Dict[int, CustomDistribution] = {}
-        self.__observer = observer.IndicesObserver()
-        self.__observer.subscribe(
-            observer.IndexEvents.DEL,
-            self.__remove_from_slot
-        )
-
-    async def server_sync(self) -> None:
-        """Sync the indices with xenaserver"""
-        _resp = await PEC_INDICES(self.__conn, self.__module_id, self.__port_id).get()
-        self.data = {
-            idx: CustomDistribution(
-                self.__observer,
-                self.__conn,
-                self.__module_id,
-                self.__port_id,
-                idx
-            )
-            for idx in _resp.indexations
-        }
-
-    def __remove_from_slot(self, index_inst: "CustomDistribution") -> None:
-        # throws ValueError if element is not exists in list of indices
-        del self.data[index_inst.custom_distribution_index]
-
-    def __setitem__(self, key, value):
-        raise NotImplementedError("Only support assign item by 'add' method")
-
-    async def remove(self, custom_distribution_index: int) -> None:
-        """Remove a index from port"""
-        await self.data[custom_distribution_index].delete()
-
-    async def __get_available_custom_distribution_index(self) -> int:
-        await self.server_sync()
-        if len(self.keys()) == 40:
-            raise ValueError("The server was full of custom distributions.")
-        return next(i for i in range(1, 41) if i not in self.keys())
-
-    async def add(self, linear: OnOff, entry_count: int, data_x: List[int], comment: str) -> "CustomDistribution":
-        cdi = await self.__get_available_custom_distribution_index()
-        cd = CustomDistribution(
-            self.__observer,
-            self.__conn,
-            self.__module_id,
-            self.__port_id,
-            custom_distribution_index=cdi,
-        )
-        await cd.definition.set(linear=linear, symmetric=OnOff.OFF, entry_count=entry_count, data_x=data_x)
-        await cd.comment.set(comment)
-        self.data[cdi] = cd
-        return cd

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

@@ -1,102 +0,0 @@
-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 ImpairmentDistribution:
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, impairment_type_index: "ImpairmentTypeIndex") -> None:
-        self.off = PED_OFF(conn, module_id, port_id, flow_index, impairment_type_index)
-        """Impairments Distribution to OFF.
-        Representation of PED_OFF
-        """
-
-        self.fixed_rate = PED_FIXED(conn, module_id, port_id, flow_index, impairment_type_index)
-        """Fixed Rate distribution configuration.
-        Representation of PED_FIXED
-        """
-
-        self.random_rate = PED_RANDOM(conn, module_id, port_id, flow_index, impairment_type_index)
-        """Random Rate distribution configuration.
-        Representation of PED_RANDOM
-        """
-
-        self.bit_error_rate = PED_BER(conn, module_id, port_id, flow_index, impairment_type_index)
-        """Bit Error Rate distribution configuration.
-        Representation of PED_BER
-        """
-
-        self.random_burst = PED_RANDOMBURST(conn, module_id, port_id, flow_index, impairment_type_index)
-        """Random Burst configuration.
-        Representation of PED_RANDOMBURST
-        """
-
-        self.ge = PED_GE(conn, module_id, port_id, flow_index, impairment_type_index)
-        """Gilbert-Elliot distribution configuration.
-        Representation of PED_GE
-        """
-
-        self.uniform = PED_UNI(conn, module_id, port_id, flow_index, impairment_type_index)
-        """Uniform distribution configuration.
-        Representation of PED_UNI
-        """
-
-        self.gaussian = PED_GAUSS(conn, module_id, port_id, flow_index, impairment_type_index)
-        """Gaussian distribution configuration.
-        Representation of PED_GAUSS
-        """
-
-        self.poisson = PED_POISSON(conn, module_id, port_id, flow_index, impairment_type_index)
-        """Poisson distribution configuration.
-        Representation of PED_POISSON
-        """
-
-        self.gamma = PED_GAMMA(conn, module_id, port_id, flow_index, impairment_type_index)
-        """Gamma distribution configuration.
-        Representation of 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.
-        Representation of PED_CUST
-        """
-
-        self.constant_delay = PED_CONST(conn, module_id, port_id, flow_index, impairment_type_index)
-        """Constant Delay distribution configuration.
-        Representation of PED_CONST
-        """
-
-        self.accumulate_and_burst = PED_ACCBURST(conn, module_id, port_id, flow_index, impairment_type_index)
-        """Accumulate & Burst distribution configuration.
-        Representation of PED_ACCBURST
-        """
-
-        self.step = PED_STEP(conn, module_id, port_id, flow_index, impairment_type_index)
-        """Step distribution configuration.
-        Representation of PED_STEP
-        """
-
-        self.fixed_burst = PED_FIXEDBURST(conn, module_id, port_id, flow_index, impairment_type_index)
-        """Fixed Burst distribution configuration.
-        Representation of PED_FIXEDBURST
-        """

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

@@ -1,113 +0,0 @@
-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_v2.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.
-        Representation of P_CAPABILITIES
-        """
-
-        self.capabilities_ext = P_CAPABILITIES_EXT(conn, module_id, port_id)
-        """Chimera port capabilities ext.
-
-        Representation of P_CAPABILITIES_EXT
-        """
-
-        self.interface = P_INTERFACE(conn, module_id, port_id)
-        """Physical interface type of the Chimera port.
-        Representation of P_INTERFACE
-        """
-
-        self.status = P_STATUS(conn, module_id, port_id)
-        """Chimera port's received optical signal level'.
-        Representation of P_STATUS
-        """
-
-        self.tx_enable = P_TXENABLE(conn, module_id, port_id)
-        """Enabling Chimera port TX.
-        Representation of P_TXENABLE
-        """
-
-        self.load_mode = P_LOADMODE(conn, module_id, port_id)
-        """Load mode of the Chimera port.
-        Representation of 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.
-        Representation of 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.
-    """
-    ...