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

xoa_driver/internals/hli_v2/ports/port_l47/main.py

@@ -1,137 +0,0 @@
-import functools
-from typing import TYPE_CHECKING
-from typing import Self
-
-from xoa_driver.internals.commands import (
-    P4_TRAFFIC,
-    P4_STATE,
-    P4_CAPABILITIES,
-    P4_STATE_STATUS,
-    P4_VLAN_OFFLOAD,
-    P4_ARP_CONFIG,
-    P4_NDP_CONFIG,
-    P4_CAPTURE,
-    P4_CAPTURE_GET_FIRST,
-    P4_CAPTURE_GET_NEXT,
-    P4_TX_PACKET_SIZE,
-    P4_RX_PACKET_SIZE,
-    P4_TX_MTU,
-    P4_RX_MTU,
-    P4_CLEAR,
-    P4_SPEEDSELECTION,
-    P4_MAX_PACKET_RATE,
-    P4_PCI_INFO,
-    P4_FW_VER,
-    P4_DEV_NAME,
-    P4_PORT_TYPE,
-    P4_LICENSE_INFO,
-    P4_APTITUDES,
-)
-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.state_storage import ports_state
-from xoa_driver.internals.utils import attributes as utils
-from xoa_driver.internals.utils.indices import index_manager as im
-from xoa_driver.internals.hli_v2.indices.connection_group.cg import ConnectionGroupIdx
-
-from .counters import PCounters
-from .packet_engine import PacketEngine
-
-
-class PCapture:
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
-        self.start = P4_CAPTURE(conn, module_id, port_id)
-        self.get_first_frame = P4_CAPTURE_GET_FIRST(conn, module_id, port_id)
-        self.get_next_frame = P4_CAPTURE_GET_NEXT(conn, module_id, port_id)
-
-
-class PortL47(base_port.BasePort["ports_state.PortL47LocalState"]):
-    """L47 Port"""
-
-    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.PortL47LocalState()
-
-        self.traffic = P4_TRAFFIC(self._conn, module_id, port_id)
-        """Representation of P4_TRAFFIC"""
-        self.clear = P4_CLEAR(self._conn, module_id, port_id)
-        """Representation of P4_CLEAR"""
-        self.state = P4_STATE(self._conn, module_id, port_id)
-        """Representation of P4_STATE"""
-        self.type = P4_PORT_TYPE(self._conn, module_id, port_id)
-        """Representation of P4_PORT_TYPE"""
-        self.aptitudes = P4_APTITUDES(self._conn, module_id, port_id)
-        """Representation of P4_APTITUDES"""
-        self.last_state_status = P4_STATE_STATUS(self._conn, module_id, port_id)
-        """Representation of P4_STATE_STATUS"""
-
-        self.nic_name = P4_DEV_NAME(self._conn, module_id, port_id)
-        """Representation of P4_DEV_NAME"""
-        self.nic_firmware_version = P4_FW_VER(self._conn, module_id, port_id)
-        """Representation of P4_FW_VER"""
-        self.vlan_offload = P4_VLAN_OFFLOAD(self._conn, module_id, port_id)
-        """Representation of P4_VLAN_OFFLOAD"""
-
-        self.max_packet_rate = P4_MAX_PACKET_RATE(self._conn, module_id, port_id)
-        """Representation of P4_MAX_PACKET_RATE"""
-        self.capabilities = P4_CAPABILITIES(self._conn, module_id, port_id)
-        """Representation of P4_CAPABILITIES"""
-        self.speed_selection = P4_SPEEDSELECTION(self._conn, module_id, port_id)
-        """Representation of P4_SPEEDSELECTION"""
-
-        # region Not sure if this commands must be at this level
-        self.tx_packet_size = P4_TX_PACKET_SIZE(self._conn, module_id, port_id)
-        """Representation of P4_TX_PACKET_SIZE"""
-        self.rx_packet_size = P4_RX_PACKET_SIZE(self._conn, module_id, port_id)
-        """Representation of P4_RX_PACKET_SIZE"""
-        self.tx_mtu = P4_TX_MTU(self._conn, module_id, port_id)
-        """Representation of P4_TX_MTU"""
-        self.rx_mtu = P4_RX_MTU(self._conn, module_id, port_id)
-        """Representation of P4_RX_MTU"""
-        # endregion
-
-        self.pci_info = P4_PCI_INFO(self._conn, module_id, port_id)
-        """Representation of P4_PCI_INFO"""
-        self.license_info = P4_LICENSE_INFO(self._conn, module_id, port_id)
-        """Representation of P4_LICENSE_INFO"""
-
-        self.arp_config = P4_ARP_CONFIG(self._conn, module_id, port_id)
-        """Representation of P4_ARP_CONFIG"""
-        self.ndp_config = P4_NDP_CONFIG(self._conn, module_id, port_id)
-        """Representation of P4_NDP_CONFIG"""
-
-        self.capture = PCapture(self._conn, module_id, port_id)
-        """L47 packet capture"""
-        self.counters = PCounters(self._conn, module_id, port_id)
-        """L47 counters"""
-        self.packet_engine = PacketEngine(self._conn, module_id, port_id)
-        """L47 packet engine"""
-
-        self.connection_groups: "im.IndexManager[ConnectionGroupIdx]" = im.IndexManager(
-            self._conn,
-            ConnectionGroupIdx,
-            module_id,
-            port_id
-        )
-        """L47 connection group index manager."""
-
-    @property
-    def info(self) -> ports_state.PortL47LocalState:
-        return self._local_states
-
-    async def _setup(self) -> Self:
-        await self._local_states.initiate(self)
-        self._local_states.register_subscriptions(self)
-        return self
-
-    on_capabilities_change = functools.partialmethod(utils.on_event, P4_CAPABILITIES)
-    """Register a callback to the event that the L47 port's capabilities change."""
-    on_speed_selection_change = functools.partialmethod(utils.on_event, P4_SPEEDSELECTION)
-    """Register a callback to the event that the L47 port's speed mode changes."""
-    on_state_change = functools.partialmethod(utils.on_event, P4_STATE)
-    """Register a callback to the event that the L47 port's state changes."""
-    on_license_info_change = functools.partialmethod(utils.on_event, P4_LICENSE_INFO)
-    """Register a callback to the event that the L47 port's license information changes."""

xoa_driver/internals/hli_v2/ports/port_l47/packet_engine.py

@@ -1,20 +0,0 @@
-from xoa_driver.internals.core import interfaces as itf
-from xoa_driver.internals.commands import (
-    P4E_ASSIGN,
-    P4E_AVAILABLE,
-    P4E_ALLOCATE,
-    P4E_ALLOCATION_INFO,
-)
-
-
-class PacketEngine:
-    """L47 port's packet engine."""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
-        self.assign = P4E_ASSIGN(conn, module_id, port_id)
-        """Representation of P4E_ASSIGN"""
-        self.available = P4E_AVAILABLE(conn, module_id, port_id)
-        """Representation of P4E_AVAILABLE"""
-        self.allocate = P4E_ALLOCATE(conn, module_id, port_id)
-        """Representation of P4E_ALLOCATE"""
-        self.allocation_info = P4E_ALLOCATION_INFO(conn, module_id, port_id)
-        """Representation of P4E_ALLOCATION_INFO"""

xoa_driver/internals/hli_v2/revisions.py

@@ -1,11 +0,0 @@
-from functools import partial
-from xoa_driver.internals.utils.rev_tool import RegisterModule
-
-VALKYRIE_MODULES = {}
-CHIMERA_MODULES = {}
-VULCAN_MODULES = {}
-
-
-register_valkyrie_module = partial(RegisterModule, modules_store=VALKYRIE_MODULES)
-register_chimera_module = partial(RegisterModule, modules_store=CHIMERA_MODULES)
-register_vulcan_module = partial(RegisterModule, modules_store=VULCAN_MODULES)

xoa_driver/internals/hli_v2/testers/_base_tester.py

@@ -1,207 +0,0 @@
-from __future__ import annotations
-from typing import (
-    TypeVar,
-    Awaitable,
-    Generic,
-    Callable,
-    Generator,
-    Any
-)
-from abc import (
-    ABC,
-    abstractmethod,
-)
-import functools
-from xoa_driver.internals.commands import enums
-from xoa_driver.internals.commands import (
-    C_RESERVATION,
-    C_DOWN,
-    C_PASSWORD,
-    C_TIME,
-    C_CAPABILITIES,
-    C_DEBUGLOGS,
-    C_NAME,
-    C_MODEL,
-    C_COMMENT,
-    C_VERSIONNO,
-    C_SERIALNO,
-    C_RESERVEDBY,
-)
-from xoa_driver.internals.core.funcs import establish_connection
-from xoa_driver.internals.core.transporter.handler import TransportationHandler
-from xoa_driver.internals.core.transporter.logger import CustomLogger
-
-from xoa_driver.internals.utils import session
-from xoa_driver.internals.state_storage import testers_state
-
-
-T = TypeVar('T', bound="BaseTester")
-TesterStateStorage = TypeVar('TesterStateStorage', bound="testers_state.TesterLocalState")
-
-
-# min version = rel v83.2 eq fw v446.5
-class BaseTester(ABC, Generic[TesterStateStorage]):
-    """
-    Basic Tester class of APIv2.
-
-    :param host: tester's address/hostname
-    :type host: str
-    :param username: username of the user
-    :type username: str
-    :param password: login password of the tester, defaults to "xena"
-    :type password: str, optional
-    :param port: the port number for connection establishment, default to 22606
-    :type port: int, optional
-    :param enable_logging: `True` if debug log output from the tester is needed, and `False` otherwise
-    :type enable_logging: bool
-    :param custom_logger: `None` allow to specify logger with custom configurations
-    :type enable_logging: CustomLogger | None
-    :param session_timeout: `130` Session timeout in seconds
-    :type session_timeout: int
-    """
-
-    def __init__(self, host: str, username: str, password: str = "xena", port: int = 22606, *, enable_logging: bool = False, custom_logger: CustomLogger | None = None, session_timeout: int = 130) -> None:
-        self.__host = host
-        self.__port = port
-        self._conn = TransportationHandler(
-            enable_logging=enable_logging,
-            custom_logger=custom_logger
-        )
-        self.session = session.TesterSession(
-            self._conn,
-            username,
-            password=password,
-            timeout_seconds=session_timeout,
-            keepalive=True,
-        )
-        """
-        Current management session
-        """
-
-        self.name = C_NAME(self._conn)
-        """
-        Tester's name.
-        Representation of C_NAME
-        """
-
-        self.comment = C_COMMENT(self._conn)
-        """Description of the tester.
-        Representation of C_COMMENT
-        """
-
-        self.model = C_MODEL(self._conn)
-        """Tester's model.
-        Representation of C_MODEL
-        """
-
-        self.version_no = C_VERSIONNO(self._conn)
-        """Tester's version number.
-        Representation of C_VERSIONNO
-        """
-
-        self.serial_no = C_SERIALNO(self._conn)
-        """Tester's serial number.
-        Representation of C_SERIALNO
-        """
-
-        self.reservation = C_RESERVATION(self._conn)
-        """Tester's reservation operation.
-        Representation of C_RESERVATION
-        """
-
-        self.reserved_by = C_RESERVEDBY(self._conn)
-        """Tester's reservation status.
-        Representation of C_RESERVEDBY
-        """
-
-        self.down = C_DOWN(self._conn)
-        """Shut down the tester.
-        Representation of C_DOWN
-        """
-
-        self.password = C_PASSWORD(self._conn)
-        """Tester's password.
-        Representation of C_PASSWORD
-        """
-
-        self.time = C_TIME(self._conn)
-        """Tester's time in seconds.
-        Representation of C_TIME
-        """
-
-        self.capabilities = C_CAPABILITIES(self._conn)
-        """Tester's capabilities.
-        Representation of C_CAPABILITIES
-        """
-
-        self.debug_log = C_DEBUGLOGS(self._conn)
-        """Tester's debug log.
-        Representation of C_DEBUGLOGS
-        """
-
-    async def __aenter__(self: Awaitable[T]) -> T:
-        return await self
-
-    async def __aexit__(self, type, value, traceback) -> None:
-        await self.session.logoff()
-
-    def __await__(self: T) -> Generator[Any, None, T]:
-        if self.session.is_online:
-            async def skip():
-                return self
-            return skip().__await__()
-        return self._setup().__await__()
-
-    async def _setup(self: T) -> T:
-        await establish_connection(self._conn, self.__host, self.__port)
-        await self.session.logon()
-        return self
-
-    def __is_reservation(self, reserved_status: enums.ReservedStatus) -> bool:
-        return self.info.reservation == reserved_status
-
-    is_released = functools.partialmethod(__is_reservation, enums.ReservedStatus.RELEASED)
-    """Validate if the tester is released.
-    """
-
-    is_reserved_by_me = functools.partialmethod(__is_reservation, enums.ReservedStatus.RESERVED_BY_YOU)
-    """Validate if the tester is reserved by my connection.
-    """
-
-    @property
-    @abstractmethod
-    def info(self) -> TesterStateStorage:
-        """
-        Tester's local information.
-        """
-        raise NotImplementedError()
-
-    # region Events
-
-    # We are not supporting Subscription on Connection made, coz Connection is happens at Awaiting of instance
-    # but subscription only registered after instance is already created, means already connected,
-    # means On_connected event will never b called, it's can be twiked, but then Creating process of tester instance
-    # will be less intuitive, and in one case subscription will work while in another not.
-
-    def on_disconnected(self, callback: "Callable") -> None:
-        """
-        Register a callback which will be called at the time when connection will be closed.
-        """
-
-        self._conn.on_disconnected(callback)
-
-    def on_reservation_change(self, callback: "Callable") -> None:
-        """
-        Register an callback function to C_RESERVATION event.
-        """
-
-        self._conn.subscribe(C_RESERVATION, callback)
-
-    def on_reserved_by_change(self, callback: "Callable") -> None:
-        """
-        Register an callback function to C_RESERVEDBY event.
-        """
-
-        self._conn.subscribe(C_RESERVEDBY, callback)
-
-    # endregion

xoa_driver/internals/hli_v2/testers/genuine/l_23/health.py

@@ -1,16 +0,0 @@
-from xoa_driver.internals.core import interfaces as itf
-from xoa_driver.internals.commands import (
-    C_HEALTH,
-)
-
-
-class Health:
-    """File uploading functions of the Valkyrie tester."""
-
-    def __init__(self, conn: "itf.IConnection") -> None:
-        self.all = C_HEALTH(conn, [])
-        """All chassis health information"""
-        self.info = C_HEALTH(conn, [0])
-        """Chassis identification information"""
-        self.uptime = C_HEALTH(conn, [1])
-        """Chassis system uptime"""

xoa_driver/internals/hli_v2/testers/genuine/l_23/rest_api.py

@@ -1,34 +0,0 @@
-from xoa_driver.internals.core import interfaces as itf
-from xoa_driver.internals.commands import (
-    C_RESTPORT,
-    C_RESTENABLE,
-    C_RESTSTATUS,
-    C_RESTCONTROL,
-)
-
-
-class RestApiServer:
-    """
-    Rest API server for the Valkyrie tester
-    """
-
-    def __init__(self, conn: "itf.IConnection") -> None:
-        self.port = C_RESTPORT(conn)
-        """TCP port for the REST server.
-        Representation of C_RESTPORT
-        """
-
-        self.enable = C_RESTENABLE(conn)
-        """Enable the REST server.
-        Representation of C_RESTENABLE
-        """
-
-        self.status = C_RESTSTATUS(conn)
-        """Status of the REST server.
-        Representation of C_RESTSTATUS
-        """
-
-        self.control = C_RESTCONTROL(conn)
-        """Control the REST server.
-        Representation of C_RESTCONTROL
-        """

xoa_driver/internals/hli_v2/testers/genuine/l_23/time_keeper.py

@@ -1,50 +0,0 @@
-from xoa_driver.internals.core import interfaces as itf
-from xoa_driver.internals.commands import (
-    C_TKLICFILE,
-    C_TKLICSTATE,
-    C_TKSTATUS,
-    C_TKSTATUSEXT,
-    C_TKSVCSTATE,
-    C_TKGPSSTATE,
-    C_TKCONFIG,
-)
-
-
-class TimeKeeper:
-    """TimeKeeper of Valkyrie."""
-
-    def __init__(self, conn: "itf.IConnection") -> None:
-        self.license_file = C_TKLICFILE(conn)
-        """TimeKeeper license file content.
-        Representation of C_TKLICFILE
-        """
-
-        self.license_state = C_TKLICSTATE(conn)
-        """State of TimeKeeper license file content.
-        Representation of C_TKLICSTATE
-        """
-
-        self.status = C_TKSTATUS(conn)
-        """Version and status of TimeKeeper.
-        Representation of C_TKSTATUS
-        """
-
-        self.status_extended = C_TKSTATUSEXT(conn)
-        """Version and status of TimeKeeper (extended).
-        Representation of C_TKSTATUSEXT
-        """
-
-        self.svc_state = C_TKSVCSTATE(conn)
-        """TimeKeeper service state.
-        Representation of C_TKSVCSTATE
-        """
-
-        self.gps_state = C_TKGPSSTATE(conn)
-        """TimeKeeper GPS state.
-        Representation of C_TKGPSSTATE
-        """
-
-        self.config_file = C_TKCONFIG(conn)
-        """TimeKeeper configuration file content.
-        Representation of C_TKCONFIG
-        """

xoa_driver/internals/hli_v2/testers/genuine/l_23/upload_file.py

@@ -1,26 +0,0 @@
-from xoa_driver.internals.core import interfaces as itf
-from xoa_driver.internals.commands import (
-    C_FILESTART,
-    C_FILEDATA,
-    C_FILEFINISH
-)
-
-
-class UploadFile:
-    """File uploading functions of the Valkyrie tester."""
-
-    def __init__(self, conn: "itf.IConnection") -> None:
-        self.start = C_FILESTART(conn)
-        """Start uploading file.
-        Representation of C_FILESTART
-        """
-
-        self.data = C_FILEDATA(conn)
-        """Uploading a file fragment.
-        Representation of C_FILEDATA
-        """
-
-        self.finish = C_FILEFINISH(conn)
-        """Finish uploading file.
-        Representation of C_FILEFINISH
-        """

xoa_driver/internals/hli_v2/testers/genuine/management_interface.py

@@ -1,38 +0,0 @@
-from xoa_driver.internals.core import interfaces as itf
-from xoa_driver.internals.commands import (
-    C_IPADDRESS,
-    C_DHCP,
-    C_MACADDRESS,
-    C_HOSTNAME,
-)
-
-
-class ManagementInterface:
-    """
-    Tester management interface address configuration.
-    """
-
-    def __init__(self, conn: "itf.IConnection") -> None:
-        self.ip_address = C_IPADDRESS(conn)
-        """
-        Chassis management port IP address configuration.
-        Representation of C_IPADDRESS
-        """
-
-        self.dhcp = C_DHCP(conn)
-        """
-        Chassis management port IP address configuration with DHCP.
-        Representation of C_DHCP
-        """
-
-        self.macaddress = C_MACADDRESS(conn)
-        """
-        Chassis management port MAC address.
-        Representation of C_MACADDRESS
-        """
-
-        self.hostname = C_HOSTNAME(conn)
-        """
-        Chassis management hostname.
-        Representation of C_HOSTNAME
-        """