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

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

@@ -0,0 +1,146 @@
+from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P4_ETH_TX_COUNTERS,
+    P4_ETH_RX_COUNTERS,
+    P4_PORT_TX_COUNTERS,
+    P4_PORT_RX_COUNTERS,
+    P4_PORT_COUNTERS,
+    P4_IPV4_RX_COUNTERS,
+    P4_IPV4_TX_COUNTERS,
+    P4_IPV4_COUNTERS,
+    P4_IPV6_RX_COUNTERS,
+    P4_IPV6_TX_COUNTERS,
+    P4_IPV6_COUNTERS,
+    P4_ARP_RX_COUNTERS,
+    P4_ARP_TX_COUNTERS,
+    P4_ARP_COUNTERS,
+    P4_NDP_RX_COUNTERS,
+    P4_NDP_TX_COUNTERS,
+    P4_NDP_COUNTERS,
+    P4_ICMP_RX_COUNTERS,
+    P4_ICMP_TX_COUNTERS,
+    P4_ICMP_COUNTERS,
+    P4_TCP_RX_COUNTERS,
+    P4_TCP_TX_COUNTERS,
+    P4_TCP_COUNTERS,
+    P4_UDP_RX_COUNTERS,
+    P4_UDP_TX_COUNTERS,
+    P4_UDP_COUNTERS,
+    P4_CLEAR_COUNTERS,
+    P4_ETH_COUNTERS,
+)
+
+
+class PCountersIPv4:
+    """IPV4 statistics"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = P4_IPV4_RX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_IPV4_RX_COUNTERS"""
+        self.tx = P4_IPV4_TX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_IPV4_TX_COUNTERS"""
+        self.total = P4_IPV4_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_IPV4_COUNTERS"""
+
+
+class PCountersIPv6:
+    """IPV6 statistics"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = P4_IPV6_RX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_IPV6_RX_COUNTERS"""
+        self.tx = P4_IPV6_TX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_IPV6_TX_COUNTERS"""
+        self.total = P4_IPV6_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_IPV6_COUNTERS"""
+
+
+class PCountersICMP:
+    """ICMP statistics"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = P4_ICMP_RX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_ICMP_RX_COUNTERS"""
+        self.tx = P4_ICMP_TX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_ICMP_TX_COUNTERS"""
+        self.total = P4_ICMP_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_ICMP_COUNTERS"""
+
+
+class PCountersTCP:
+    """ICMP statistics"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = P4_TCP_RX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_TCP_RX_COUNTERS"""
+        self.tx = P4_TCP_TX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_TCP_TX_COUNTERS"""
+        self.total = P4_TCP_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_TCP_COUNTERS"""
+
+
+class PCountersUDP:
+    """ICMP statistics"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = P4_UDP_RX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_UDP_RX_COUNTERS"""
+        self.tx = P4_UDP_TX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_UDP_TX_COUNTERS"""
+        self.total = P4_UDP_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_UDP_COUNTERS"""
+
+
+class PCountersETH:
+    """ICMP statistics"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = P4_ETH_RX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_ETH_RX_COUNTERS"""
+        self.tx = P4_ETH_TX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_ETH_TX_COUNTERS"""
+        self.total = P4_ETH_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_ETH_COUNTERS"""
+
+
+class PCountersARP:
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = P4_ARP_RX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_ARP_RX_COUNTERS"""
+        self.tx = P4_ARP_TX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_ARP_TX_COUNTERS"""
+        self.total = P4_ARP_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_ARP_COUNTERS"""
+
+
+class PCountersNDP:
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.rx = P4_NDP_RX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_NDP_RX_COUNTERS"""
+        self.tx = P4_NDP_TX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_NDP_TX_COUNTERS"""
+        self.total = P4_NDP_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_NDP_COUNTERS"""
+
+
+class PCounters:
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.clear = P4_CLEAR_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_CLEAR_COUNTERS"""
+        self.total_tx = P4_PORT_TX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_PORT_TX_COUNTERS"""
+        self.total_rx = P4_PORT_RX_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_PORT_RX_COUNTERS"""
+        self.total = P4_PORT_COUNTERS(conn, module_id, port_id)
+        """Representation of P4_PORT_COUNTERS"""
+
+        self.ipv4 = PCountersIPv4(conn, module_id, port_id)
+        """L47 port IPv4 counters."""
+        self.ipv6 = PCountersIPv6(conn, module_id, port_id)
+        """L47 port IPv6 counters."""
+        self.icmp = PCountersICMP(conn, module_id, port_id)
+        """L47 port ICMP counters."""
+        self.tcp = PCountersTCP(conn, module_id, port_id)
+        """L47 port TCP counters."""
+        self.udp = PCountersUDP(conn, module_id, port_id)
+        """L47 port UDP counters."""
+        self.eth = PCountersETH(conn, module_id, port_id)
+        """L47 port Ethernet counters."""
+        self.arp = PCountersARP(conn, module_id, port_id)
+        """L47 port ARP counters."""
+        self.ndp = PCountersNDP(conn, module_id, port_id)
+        """L47 port NDP counters."""

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

@@ -0,0 +1,137 @@
+import functools
+from typing import TYPE_CHECKING
+from typing_extensions 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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,207 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,26 @@
+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
+        """