tdl-xoa-driver 1.3.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

xoa_driver/internals/hli_v2/indices/connection_group/replay.py

@@ -1,89 +0,0 @@
-from typing import TYPE_CHECKING
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-from xoa_driver.internals.commands import (
-    P4G_REPLAY_FILE_INDICES,
-    P4G_REPLAY_FILE_NAME,
-    P4G_REPLAY_FILE_CLEAR,
-    P4G_REPLAY_UTILIZATION,
-    P4G_REPLAY_USER_INCARNATION,
-    P4G_REPLAY_USER_REPETITIONS,
-    P4G_APP_REPLAY_COUNTERS,
-    # P4G_REPLAY_SCHEDULING, # TODO: need to implement
-    # P4G_REPLAY_SYNCHRONIZATION, # TODO: need to implement
-)
-
-
-class GFilesReplay:
-    """PCAP replay file configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.__conn = conn
-        self.__module_id = module_id
-        self.__port_id = port_id
-        self.__group_idx = group_idx
-        self.indices = P4G_REPLAY_FILE_INDICES(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_REPLAY_FILE_INDICES
-        """
-
-    def name(self, replay_file_idx: int) -> "P4G_REPLAY_FILE_NAME":
-        """
-        Representation of P4G_REPLAY_FILE_NAME
-        """
-        return P4G_REPLAY_FILE_NAME(
-            self.__conn,
-            self.__module_id,
-            self.__port_id,
-            self.__group_idx,
-            replay_file_idx
-        )
-
-    async def clear_index(self, replay_file_idx: int) -> None:
-        """
-        Representation of P4G_REPLAY_FILE_CLEAR
-        """
-        await P4G_REPLAY_FILE_CLEAR(
-            self.__conn,
-            self.__module_id,
-            self.__port_id,
-            replay_file_idx
-        ).set()
-
-
-class GUserReplay:
-    """PCAP replay user configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.incarnation = P4G_REPLAY_USER_INCARNATION(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_REPLAY_USER_INCARNATION
-        """
-        self.repetitions = P4G_REPLAY_USER_REPETITIONS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_REPLAY_USER_REPETITIONS
-        """
-
-
-class GCounters:
-    """PCAP replay counters"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.replay = P4G_APP_REPLAY_COUNTERS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_APP_REPLAY_COUNTERS
-        """
-
-
-class GReplay:
-    """PCAP replay configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.utilization = P4G_REPLAY_UTILIZATION(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_REPLAY_UTILIZATION
-        """
-        # self.scheduling = P4G_REPLAY_SCHEDULING(conn, module_id, port_id, group_idx)
-        # self.synchronization = P4G_REPLAY_SYNCHRONIZATION(conn, module_id, port_id, group_idx)
-        self.files = GFilesReplay(conn, module_id, port_id, group_idx)
-        """PCAP replay file configuration"""
-        self.user = GUserReplay(conn, module_id, port_id, group_idx)
-        """PCAP replay user configuration"""
-        self.counters = GCounters(conn, module_id, port_id, group_idx)
-        """PCAP replay counters"""

xoa_driver/internals/hli_v2/indices/connection_group/tcp.py

@@ -1,261 +0,0 @@
-from typing import TYPE_CHECKING
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-from xoa_driver.internals.commands import (
-    P4G_CLEAR_POST_STAT,
-    P4G_TCP_RTT_VALUE,
-    P4G_TCP_STATE_CURRENT,
-    P4G_TCP_STATE_TOTAL,
-    P4G_TCP_STATE_RATE,
-    P4G_TCP_RX_PAYLOAD_COUNTERS,
-    P4G_TCP_TX_PAYLOAD_COUNTERS,
-    P4G_TCP_RETRANSMIT_COUNTERS,
-    P4G_TCP_ERROR_COUNTERS,
-    P4G_TCP_MSS_TYPE,
-    P4G_TCP_MSS_MINMAX,
-    P4G_TCP_MSS_VALUE,
-    P4G_TCP_WINDOW_SIZE,
-    P4G_TCP_DUP_THRES,
-    P4G_TCP_SYN_RTO,
-    P4G_TCP_RTO,
-    P4G_TCP_CONGESTION_MODE,
-    P4G_TCP_WINDOW_SCALING,
-    P4G_TCP_RTO_MINMAX,
-    P4G_TCP_RTO_PROLONGED_MODE,
-    P4G_TCP_ICWND_CALC_METHOD,
-    P4G_TCP_ISSTHRESH,
-    P4G_TCP_ACK_FREQUENCY,
-    P4G_TCP_ACK_TIMEOUT,
-    P4G_TCP_ESTABLISH_HIST,
-    P4G_TCP_CLOSE_HIST,
-    P4G_TCP_RX_TOTAL_BYTES_HIST,
-    P4G_TCP_RX_GOOD_BYTES_HIST,
-    P4G_TCP_TX_TOTAL_BYTES_HIST,
-    P4G_TCP_TX_GOOD_BYTES_HIST,
-    P4G_TCP_RX_PACKET_COUNTERS,
-    P4G_TCP_TX_PACKET_COUNTERS,
-)
-
-
-class GAckTcp:
-    """TCP ACK configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.duplicate_tresholds = P4G_TCP_DUP_THRES(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_DUP_THRES
-        """
-        self.frequency = P4G_TCP_ACK_FREQUENCY(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_ACK_FREQUENCY
-        """
-        self.timeout = P4G_TCP_ACK_TIMEOUT(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_ACK_TIMEOUT
-        """
-
-
-class GRetransmitionTimeoutTcp:
-    """TCP Retransmition Timeout configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.syn_value = P4G_TCP_SYN_RTO(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_SYN_RTO
-        """
-        self.value = P4G_TCP_RTO(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_RTO
-        """
-        self.range_limits = P4G_TCP_RTO_MINMAX(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_RTO_MINMAX
-        """
-        self.prolonged_mode = P4G_TCP_RTO_PROLONGED_MODE(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_RTO_PROLONGED_MODE
-        """
-
-
-class GStateCountersTcp:
-    """TCP State counters"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.current = P4G_TCP_STATE_CURRENT(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_STATE_CURRENT
-        """
-        self.total = P4G_TCP_STATE_TOTAL(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_STATE_TOTAL
-        """
-        self.rate = P4G_TCP_STATE_RATE(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_STATE_RATE
-        """
-
-
-class GMaxSegmentSize:
-    """TCP Max Segment Size Configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.type = P4G_TCP_MSS_TYPE(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_MSS_TYPE
-        """
-        self.range_limits = P4G_TCP_MSS_MINMAX(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_MSS_MINMAX
-        """
-        self.fixed_value = P4G_TCP_MSS_VALUE(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_MSS_VALUE
-        """
-
-
-class GPacketCountersTcp:
-    """TCP Packet Counters"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.rx = P4G_TCP_RX_PACKET_COUNTERS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_RX_PACKET_COUNTERS
-        """
-        self.tx = P4G_TCP_TX_PACKET_COUNTERS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_TX_PACKET_COUNTERS
-        """
-
-
-class GPayloadCountersTcp:
-    """TCP Payload Counters"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.rx = P4G_TCP_RX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_RX_PAYLOAD_COUNTERS
-        """
-        self.tx = P4G_TCP_TX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_TX_PAYLOAD_COUNTERS
-        """
-
-
-class GCountersTcp:
-    """TCP counters"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.retransmission = P4G_TCP_RETRANSMIT_COUNTERS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_RETRANSMIT_COUNTERS
-        """
-        self.error = P4G_TCP_ERROR_COUNTERS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_ERROR_COUNTERS
-        """
-        self.packet = GPacketCountersTcp(conn, module_id, port_id, group_idx)
-        """Packet counters"""
-        self.payload = GPayloadCountersTcp(conn, module_id, port_id, group_idx)
-        """Payload counters"""
-        self.state = GStateCountersTcp(conn, module_id, port_id, group_idx)
-        """State counters"""
-
-
-class GRxHistogramTcp:
-    """TCP RX Histogram"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.total_bytes = P4G_TCP_RX_TOTAL_BYTES_HIST(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_RX_TOTAL_BYTES_HIST
-        """
-        self.good_bytes = P4G_TCP_RX_GOOD_BYTES_HIST(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_RX_GOOD_BYTES_HIST
-        """
-
-
-class GTxHistogramTcp:
-    """TCP TX Histogram"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.total_bytes = P4G_TCP_TX_TOTAL_BYTES_HIST(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_TX_TOTAL_BYTES_HIST
-        """
-        self.good_bytes = P4G_TCP_TX_GOOD_BYTES_HIST(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_TX_GOOD_BYTES_HIST
-        """
-
-
-class GConnHistogramTcp:
-    """TCP Connection Histogram"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.establish_times = P4G_TCP_ESTABLISH_HIST(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_ESTABLISH_HIST
-        """
-        self.close_times = P4G_TCP_CLOSE_HIST(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_CLOSE_HIST
-        """
-
-
-class GHistogramTcp:
-    """TCP histogram"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.connection = GConnHistogramTcp(conn, module_id, port_id, group_idx)
-        """TCP Connection Histogram"""
-        self.rx = GRxHistogramTcp(conn, module_id, port_id, group_idx)
-        """TCP RX Histogram"""
-        self.tx = GTxHistogramTcp(conn, module_id, port_id, group_idx)
-        """TCP TX Histogram"""
-
-
-class GReceiverWindowTcp:
-    """TCP RWND Configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.size = P4G_TCP_WINDOW_SIZE(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_WINDOW_SIZE
-        """
-        self.scaling = P4G_TCP_WINDOW_SCALING(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_WINDOW_SCALING
-        """
-
-
-class GCongestionWindowTcp:
-    """TCP CWND Configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.congestion_mode = P4G_TCP_CONGESTION_MODE(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_CONGESTION_MODE
-        """
-        self.icwnd_calc_method = P4G_TCP_ICWND_CALC_METHOD(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_ICWND_CALC_METHOD
-        """
-
-
-class GTcp:
-    """TCP Stack Configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.clear_post_test_statistics = P4G_CLEAR_POST_STAT(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_CLEAR_POST_STAT
-        """
-        self.rtt_value = P4G_TCP_RTT_VALUE(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_RTT_VALUE
-        """
-        self.iss_treshold = P4G_TCP_ISSTHRESH(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TCP_ISSTHRESH
-        """
-        self.mss = GMaxSegmentSize(conn, module_id, port_id, group_idx)
-        """Max segment size config"""
-        self.rto = GRetransmitionTimeoutTcp(conn, module_id, port_id, group_idx)
-        """Retransmission timeout config"""
-        self.ack = GAckTcp(conn, module_id, port_id, group_idx)
-        """ACK config"""
-        self.rwnd = GReceiverWindowTcp(conn, module_id, port_id, group_idx)
-        """RWND config"""
-        self.cwnd = GCongestionWindowTcp(conn, module_id, port_id, group_idx)
-        """CWND config"""
-        self.counters = GCountersTcp(conn, module_id, port_id, group_idx)
-        """Counters"""
-        self.histogram = GHistogramTcp(conn, module_id, port_id, group_idx)
-        """Histogram"""

xoa_driver/internals/hli_v2/indices/connection_group/tls.py

@@ -1,166 +0,0 @@
-from typing import TYPE_CHECKING
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-from xoa_driver.internals.commands import (
-    P4G_TLS_ENABLE,
-    P4G_TLS_CIPHER_SUITES,
-    P4G_TLS_MAX_RECORD_SIZE,
-    P4G_TLS_CERTIFICATE_FILENAME,
-    P4G_TLS_PRIVATE_KEY_FILENAME,
-    P4G_TLS_DHPARAMS_FILENAME,
-    P4G_TLS_CLOSE_NOTIFY,
-    P4G_TLS_ALERT_WARNING_COUNTERS,
-    P4G_TLS_ALERT_FATAL_COUNTERS,
-    P4G_TLS_STATE_CURRENT,
-    P4G_TLS_STATE_TOTAL,
-    P4G_TLS_STATE_RATE,
-    P4G_TLS_RX_PAYLOAD_COUNTERS,
-    P4G_TLS_TX_PAYLOAD_COUNTERS,
-    P4G_TLS_RX_PAYLOAD_BYTES_HIST,
-    P4G_TLS_TX_PAYLOAD_BYTES_HIST,
-    P4G_TLS_HANDSHAKE_HIST,
-    P4G_TLS_SERVER_NAME,
-    P4G_TLS_PROTOCOL_VER,
-    P4G_TLS_MIN_REQ_PROTOCOL_VER,
-)
-
-
-class GCountersTlsState:
-    """TLS state counters"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.current = P4G_TLS_STATE_CURRENT(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_STATE_CURRENT
-        """
-        self.total = P4G_TLS_STATE_TOTAL(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_STATE_TOTAL
-        """
-        self.rate = P4G_TLS_STATE_RATE(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_STATE_RATE
-        """
-
-
-class GCountersTlsAlert:
-    """TLS alert counters"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.warning = P4G_TLS_ALERT_WARNING_COUNTERS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_ALERT_WARNING_COUNTERS
-        """
-        self.fatal = P4G_TLS_ALERT_FATAL_COUNTERS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_ALERT_FATAL_COUNTERS
-        """
-
-
-class GCountersTlsPayload:
-    """TLS payload counters"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.rx = P4G_TLS_RX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_RX_PAYLOAD_COUNTERS
-        """
-        self.tx = P4G_TLS_TX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_TX_PAYLOAD_COUNTERS
-        """
-
-
-class GCountersTls:
-    """TLS counters"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.alert = GCountersTlsAlert(conn, module_id, port_id, group_idx)
-        """TLS alert counters"""
-        self.payload = GCountersTlsPayload(conn, module_id, port_id, group_idx)
-        """TLS payload counters"""
-        self.state = GCountersTlsState(conn, module_id, port_id, group_idx)
-        """TLS state counters"""
-
-
-class GHistogramTlsPayload:
-    """TLS payload histogram"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.rx_bytes = P4G_TLS_RX_PAYLOAD_BYTES_HIST(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_RX_PAYLOAD_BYTES_HIST
-        """
-        self.tx_bytes = P4G_TLS_TX_PAYLOAD_BYTES_HIST(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_TX_PAYLOAD_BYTES_HIST
-        """
-
-
-class GHistogramTls:
-    """TLS histogram"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.handshake = P4G_TLS_HANDSHAKE_HIST(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_HANDSHAKE_HIST
-        """
-        self.payload = GHistogramTlsPayload(conn, module_id, port_id, group_idx)
-        """TLS payload histogram"""
-
-
-class GProtocolTls:
-    """TLS protocol version"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.version = P4G_TLS_PROTOCOL_VER(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_PROTOCOL_VER
-        """
-        self.min_required_version = P4G_TLS_MIN_REQ_PROTOCOL_VER(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_MIN_REQ_PROTOCOL_VER
-        """
-
-
-class GFileTls:
-    """TLS certificate and key files"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.certificate_path = P4G_TLS_CERTIFICATE_FILENAME(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_CERTIFICATE_FILENAME
-        """
-        self.private_key_path = P4G_TLS_PRIVATE_KEY_FILENAME(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_PRIVATE_KEY_FILENAME
-        """
-        self.dhparams_path = P4G_TLS_DHPARAMS_FILENAME(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_DHPARAMS_FILENAME
-        """
-
-
-class GTls:
-    """TLS configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.enable = P4G_TLS_ENABLE(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_ENABLE
-        """
-        self.server_name = P4G_TLS_SERVER_NAME(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_SERVER_NAME
-        """
-        self.close_notify = P4G_TLS_CLOSE_NOTIFY(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_CLOSE_NOTIFY
-        """
-        self.cipher_suites = P4G_TLS_CIPHER_SUITES(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_CIPHER_SUITES
-        """
-        self.max_record_size = P4G_TLS_MAX_RECORD_SIZE(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TLS_MAX_RECORD_SIZE
-        """
-        self.file = GFileTls(conn, module_id, port_id, group_idx)
-        """Cert and key file"""
-        self.protocol = GProtocolTls(conn, module_id, port_id, group_idx)
-        """Protocol version"""
-        self.counters = GCountersTls(conn, module_id, port_id, group_idx)
-        """Counters"""
-        self.histogram = GHistogramTls(conn, module_id, port_id, group_idx)
-        """Histogram"""

xoa_driver/internals/hli_v2/indices/connection_group/udp.py

@@ -1,112 +0,0 @@
-from typing import TYPE_CHECKING
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-from xoa_driver.internals.commands import (
-    P4G_UDP_PACKET_SIZE_TYPE,
-    P4G_UDP_PACKET_SIZE_MINMAX,
-    P4G_UDP_PACKET_SIZE_VALUE,
-    P4G_UDP_STATE_CURRENT,
-    P4G_UDP_STATE_TOTAL,
-    P4G_UDP_STATE_RATE,
-    P4G_UDP_RX_PAYLOAD_COUNTERS,
-    P4G_UDP_TX_PAYLOAD_COUNTERS,
-    P4G_UDP_RX_BYTES_HIST,
-    P4G_UDP_TX_BYTES_HIST,
-    P4G_UDP_RX_PACKET_COUNTERS,
-    P4G_UDP_TX_PACKET_COUNTERS,
-)
-
-
-class GHistogramUdp:
-    """UDP histogram"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.rx_bytes = P4G_UDP_RX_BYTES_HIST(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_UDP_RX_BYTES_HIST
-        """
-        self.tx_bytes = P4G_UDP_TX_BYTES_HIST(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_UDP_TX_BYTES_HIST
-        """
-
-
-class GPayloadCountersUdp:
-    """UDP payload counters"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.rx = P4G_UDP_RX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_UDP_RX_PAYLOAD_COUNTERS
-        """
-        self.tx = P4G_UDP_TX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_UDP_TX_PAYLOAD_COUNTERS
-        """
-
-
-class GPacketCountersUdp:
-    """UDP packet counters"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.rx = P4G_UDP_RX_PACKET_COUNTERS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_UDP_RX_PACKET_COUNTERS
-        """
-        self.tx = P4G_UDP_TX_PACKET_COUNTERS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_UDP_TX_PACKET_COUNTERS
-        """
-
-
-class GCountersUdp:
-    """UDP counters"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.payload = GPayloadCountersUdp(conn, module_id, port_id, group_idx)
-        """UDP payload counters"""
-        self.packet = GPacketCountersUdp(conn, module_id, port_id, group_idx)
-        """UDP packet counters"""
-        self.state = GStateCountersUdp(conn, module_id, port_id, group_idx)
-        """UDP state counters"""
-
-
-class GPacketSizeUdp:
-    """UDP packet size"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.type = P4G_UDP_PACKET_SIZE_TYPE(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_UDP_PACKET_SIZE_TYPE
-        """
-        self.range_limits = P4G_UDP_PACKET_SIZE_MINMAX(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_UDP_PACKET_SIZE_MINMAX
-        """
-        self.value = P4G_UDP_PACKET_SIZE_VALUE(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_UDP_PACKET_SIZE_VALUE
-        """
-
-
-class GStateCountersUdp:
-    """UDP state counters"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.current = P4G_UDP_STATE_CURRENT(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_UDP_STATE_CURRENT
-        """
-        self.total = P4G_UDP_STATE_TOTAL(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_UDP_STATE_TOTAL
-        """
-        self.rate = P4G_UDP_STATE_RATE(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_UDP_STATE_RATE
-        """
-
-
-class GUdp:
-    """UDP configuration"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.packet_size = GPacketSizeUdp(conn, module_id, port_id, group_idx)
-        """UDP packet size"""
-        self.counters = GCountersUdp(conn, module_id, port_id, group_idx)
-        """UDP counters"""
-        self.histogram = GHistogramUdp(conn, module_id, port_id, group_idx)
-        """UDP histogram"""

xoa_driver/internals/hli_v2/indices/connection_group/user_state.py

@@ -1,25 +0,0 @@
-from typing import TYPE_CHECKING
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-from xoa_driver.internals.commands import (
-    P4G_USER_STATE_CURRENT,
-    P4G_USER_STATE_TOTAL,
-    P4G_USER_STATE_RATE,
-)
-
-
-class GUserState:
-    """User state counters"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.current = P4G_USER_STATE_CURRENT(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_USER_STATE_CURRENT
-        """
-        self.total = P4G_USER_STATE_TOTAL(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_USER_STATE_TOTAL
-        """
-        self.rate = P4G_USER_STATE_RATE(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_USER_STATE_RATE
-        """