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

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

@@ -1,115 +0,0 @@
-from typing import (
-    final,
-    List,
-    Type,
-    TypeVar,
-    TYPE_CHECKING,
-)
-
-from xoa_driver.internals.commands import (
-    P4G_INDICES,
-    P4G_CREATE,
-    P4G_DELETE,
-    P4G_ENABLE,
-    P4G_COMMENT,
-    P4G_CLEAR_COUNTERS,
-    P4G_ROLE,
-    P4G_LP_TIME_SCALE,
-    P4G_LP_SHAPE,
-    P4G_TEST_APPLICATION,
-    P4G_L4_PROTOCOL,
-)
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-    from xoa_driver.internals.utils import kind
-from xoa_driver.internals.utils.indices import observer as idx_obs
-from .tls import GTls
-from .l2 import GL2
-from .raw import GRaw
-from .tcp import GTcp
-from .udp import GUdp
-from .replay import GReplay
-from .l3 import GL3
-from .user_state import GUserState
-from .histogram import GHistogram
-
-from ..base_index import BaseIndex
-
-
-class GCounters:
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.clear = P4G_CLEAR_COUNTERS(conn, module_id, port_id, group_idx)
-
-
-class GLoadProfile:
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.time_scale = P4G_LP_TIME_SCALE(conn, module_id, port_id, group_idx)
-        self.shape = P4G_LP_SHAPE(conn, module_id, port_id, group_idx)
-
-
-CG = TypeVar("CG")
-
-
-@final
-class ConnectionGroupIdx(BaseIndex):
-    """L47 Connection Group Index Manager"""
-    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
-        super().__init__(conn, kind, observer)
-
-        self.comment = P4G_COMMENT(self._conn, *kind)
-        """
-        Representation of p4g_commands.P4G_COMMENT
-        """
-        self.status = P4G_ENABLE(self._conn, *kind)
-        """
-        Representation of p4g_commands.P4G_ENABLE
-        """
-        self.role = P4G_ROLE(self._conn, *kind)
-        """
-        Representation of p4g_commands.P4G_ROLE
-        """
-        self.layer4_protocol = P4G_L4_PROTOCOL(self._conn, *kind)
-        """
-        Representation of p4g_commands.P4G_L4_PROTOCOL
-        """
-        self.test_application = P4G_TEST_APPLICATION(self._conn, *kind)
-        """
-        Representation of p4g_commands.P4G_TEST_APPLICATION
-        """
-
-        self.tls = GTls(self._conn, *kind)
-        """TLS configurations."""
-        self.l2 = GL2(self._conn, *kind)
-        """L2 configurations."""
-        self.raw = GRaw(self._conn, *kind)
-        """Raw configurations."""
-        self.tcp = GTcp(self._conn, *kind)
-        """TCP configurations."""
-        self.udp = GUdp(self._conn, *kind)
-        """UDP configurations."""
-        self.replay = GReplay(self._conn, *kind)
-        """Replay configurations."""
-        self.l3 = GL3(self._conn, *kind)
-        """L3 configurations."""
-        self.user_state = GUserState(self._conn, *kind)
-        """User state configurations."""
-        self.histogram = GHistogram(self._conn, *kind)
-        """Histogram configurations."""
-        self.counters = GCounters(self._conn, *kind)
-        """Counters."""
-        self.load_profile = GLoadProfile(self._conn, *kind)
-        """Load Profile configurations."""
-
-    async def delete(self):
-        await P4G_DELETE(self._conn, *self.kind).set()
-        self._observer.notify(idx_obs.IndexEvents.DEL, self)
-
-    @classmethod
-    async def _fetch(cls, conn: "itf.IConnection", module_id: int, port_id: int) -> List[int]:
-        resp = await P4G_INDICES(conn, module_id, port_id).get()
-        return list(resp.group_identifiers)
-
-    @classmethod
-    async def _new(cls: Type[CG], conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> CG:
-        await P4G_CREATE(conn, *kind).set()
-        return cls(conn, kind, observer)

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

@@ -1,59 +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_TIME_HIST_CONF,
-    P4G_PAYLOAD_HIST_CONF,
-    P4G_TRANSACTION_HIST_CONF,
-    P4G_APP_TRANSACTION_HIST,
-    P4G_RECALC_TIME_HIST,
-    P4G_RECALC_PAYLOAD_HIST,
-    P4G_RECALC_TRANSACTION_HIST,
-)
-
-
-class GConfigHistogram:
-    """L47 Histogram Config"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.time = P4G_TIME_HIST_CONF(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TIME_HIST_CONF
-        """
-        self.payload = P4G_PAYLOAD_HIST_CONF(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_PAYLOAD_HIST_CONF
-        """
-        self.transaction = P4G_TRANSACTION_HIST_CONF(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_TRANSACTION_HIST_CONF
-        """
-
-
-class GRecalculatesHistogram:
-    """L47 Histogram Recalculation."""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.time = P4G_RECALC_TIME_HIST(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RECALC_TIME_HIST
-        """
-        self.payload = P4G_RECALC_PAYLOAD_HIST(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RECALC_PAYLOAD_HIST
-        """
-        self.transaction = P4G_RECALC_TRANSACTION_HIST(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RECALC_TRANSACTION_HIST
-        """
-
-
-class GHistogram:
-    """L47 Histogram."""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.transaction = P4G_APP_TRANSACTION_HIST(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_APP_TRANSACTION_HIST
-        """
-        self.recalculates = GRecalculatesHistogram(conn, module_id, port_id, group_idx)
-        """L47 Histogram Recalculation."""
-        self.config = GConfigHistogram(conn, module_id, port_id, group_idx)
-        """L47 Histogram Config"""

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

@@ -1,71 +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_L2_CLIENT_MAC,
-    P4G_L2_SERVER_MAC,
-    P4G_L2_USE_ADDRESS_RES,
-    P4G_L2_USE_GW,
-    P4G_L2_GW,
-    P4G_L2_IPV6_GW,
-    P4G_VLAN_ENABLE,
-    P4G_VLAN_TCI,
-)
-
-
-class GMacL2:
-    """L2 MAC"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.client = P4G_L2_CLIENT_MAC(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_L2_CLIENT_MAC
-        """
-        self.server = P4G_L2_SERVER_MAC(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_L2_SERVER_MAC
-        """
-
-
-class GGatewayL2:
-    """L2 Gateway"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.use = P4G_L2_USE_GW(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_L2_USE_GW
-        """
-        self.ipv4 = P4G_L2_GW(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_L2_GW
-        """
-        self.ipv6 = P4G_L2_IPV6_GW(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_L2_IPV6_GW
-        """
-
-
-class GVlanL2:
-    """L2 VLAN"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.enable = P4G_VLAN_ENABLE(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_VLAN_ENABLE
-        """
-        self.tci = P4G_VLAN_TCI(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_VLAN_TCI
-        """
-
-
-class GL2:
-    """L2 Configurations"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.address_resolve = P4G_L2_USE_ADDRESS_RES(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_L2_USE_ADDRESS_RES
-        """
-        self.mac = GMacL2(conn, module_id, port_id, group_idx)
-        """L2 MAC"""
-        self.gateway = GGatewayL2(conn, module_id, port_id, group_idx)
-        """L2 Gateway"""
-        self.vlan = GVlanL2(conn, module_id, port_id, group_idx)
-        """L2 VLAN"""

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

@@ -1,96 +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_CLIENT_RANGE,
-    P4G_SERVER_RANGE,
-    P4G_IP_DS_TYPE,
-    P4G_IP_DS_VALUE,
-    P4G_IP_DS_MASK,
-    P4G_IP_DS_MINMAX,
-    P4G_IP_DS_STEP,
-    P4G_IP_VERSION,
-    P4G_IPV6_CLIENT_RANGE,
-    P4G_IPV6_SERVER_RANGE,
-    P4G_IPV6_TRAFFIC_CLASS,
-    P4G_IPV6_FLOW_LABEL,
-    P4G_NAT,
-)
-
-
-class GIPv4L3:
-    """L3 IPv4"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.client_range = P4G_CLIENT_RANGE(conn, module_id, port_id, group_idx)
-        """
-        Representation P4G_CLIENT_RANGE
-        """
-        self.server_range = P4G_SERVER_RANGE(conn, module_id, port_id, group_idx)
-        """
-        Representation P4G_SERVER_RANGE
-        """
-
-
-class GIPv6L3:
-    """L3 IPv6"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.client_range = P4G_IPV6_CLIENT_RANGE(conn, module_id, port_id, group_idx)
-        """
-        Representation P4G_IPV6_CLIENT_RANGE
-        """
-        self.server_range = P4G_IPV6_SERVER_RANGE(conn, module_id, port_id, group_idx)
-        """
-        Representation P4G_IPV6_SERVER_RANGE
-        """
-        self.traffic_class = P4G_IPV6_TRAFFIC_CLASS(conn, module_id, port_id, group_idx)
-        """
-        Representation P4G_IPV6_TRAFFIC_CLASS
-        """
-        self.flow_label = P4G_IPV6_FLOW_LABEL(conn, module_id, port_id, group_idx)
-        """
-        Representation P4G_IPV6_FLOW_LABEL
-        """
-
-
-class GDifferentialServiceL3:
-    """L3 Differential Service"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.type = P4G_IP_DS_TYPE(conn, module_id, port_id, group_idx)
-        """
-        Representation P4G_IP_DS_TYPE
-        """
-        self.value = P4G_IP_DS_VALUE(conn, module_id, port_id, group_idx)
-        """
-        Representation P4G_IP_DS_VALUE
-        """
-        self.mask = P4G_IP_DS_MASK(conn, module_id, port_id, group_idx)
-        """
-        Representation P4G_IP_DS_MASK
-        """
-        self.range_limits = P4G_IP_DS_MINMAX(conn, module_id, port_id, group_idx)
-        """
-        Representation P4G_IP_DS_MINMAX
-        """
-        self.step = P4G_IP_DS_STEP(conn, module_id, port_id, group_idx)
-        """
-        Representation P4G_IP_DS_STEP
-        """
-
-
-class GL3:
-    """L3 Configurations"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.ip_version = P4G_IP_VERSION(conn, module_id, port_id, group_idx)
-        """
-        Representation P4G_IP_VERSION
-        """
-        self.ipv4 = GIPv4L3(conn, module_id, port_id, group_idx)
-        """L3 IPv4 Configurations"""
-        self.ipv6 = GIPv6L3(conn, module_id, port_id, group_idx)
-        """L3 IPv6 Configurations"""
-        self.diffserv = GDifferentialServiceL3(conn, module_id, port_id, group_idx)
-        """L3 IPv6 DS Configurations"""
-        self.nat = P4G_NAT(conn, module_id, port_id, group_idx)  # TODO: maybe to add extra logic for this command based on the description
-        """
-        Representation P4G_NAT
-        """

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

@@ -1,148 +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_RAW_TEST_SCENARIO,
-    P4G_RAW_PAYLOAD_TYPE,
-    P4G_RAW_PAYLOAD_TOTAL_LEN,
-    P4G_RAW_PAYLOAD,
-    P4G_RAW_PAYLOAD_REPEAT_LEN,
-    P4G_RAW_HAS_DOWNLOAD_REQ,
-    P4G_RAW_CLOSE_CONN,
-    P4G_RAW_UTILIZATION,
-    P4G_RAW_DOWNLOAD_REQUEST,
-    P4G_RAW_TX_DURING_RAMP,
-    P4G_RAW_TX_TIME_OFFSET,
-    P4G_RAW_BURSTY_TX,
-    P4G_RAW_BURSTY_CONF,
-    P4G_RAW_RX_PAYLOAD_LEN,
-    P4G_RAW_REQUEST_REPEAT,
-    P4G_RAW_CONN_INCARNATION,
-    P4G_RAW_CONN_REPETITIONS,
-    P4G_RAW_CONN_LIFETIME,
-    P4G_APP_TRANSACTION_COUNTERS,
-)
-
-
-class GPayloadRaw:
-    """Payload settings of Raw type of test application"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.type = P4G_RAW_PAYLOAD_TYPE(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_PAYLOAD_TYPE
-        """
-        self.total_length = P4G_RAW_PAYLOAD_TOTAL_LEN(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_PAYLOAD_TOTAL_LEN
-        """
-        self.rx_length = P4G_RAW_RX_PAYLOAD_LEN(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_RX_PAYLOAD_LEN
-        """
-        self.content = P4G_RAW_PAYLOAD(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_PAYLOAD
-        """
-        self.repeat_length = P4G_RAW_PAYLOAD_REPEAT_LEN(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_PAYLOAD_REPEAT_LEN
-        """
-
-
-class GConnectionRaw:
-    """Connection settings of Raw type of test application"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.incarnation = P4G_RAW_CONN_INCARNATION(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_CONN_INCARNATION
-        """
-        self.repetitions = P4G_RAW_CONN_REPETITIONS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_CONN_REPETITIONS
-        """
-        self.lifetime = P4G_RAW_CONN_LIFETIME(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_CONN_LIFETIME
-        """
-        self.close_condition = P4G_RAW_CLOSE_CONN(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_CLOSE_CONN
-        """
-
-
-class GBurstyRaw:
-    """Burst settings of Raw type of test application"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.transmission = P4G_RAW_BURSTY_TX(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_BURSTY_TX
-        """
-        self.config = P4G_RAW_BURSTY_CONF(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_BURSTY_CONF
-        """
-
-
-class GTransmitRaw:
-    """Tranmission settings of Raw type of test application"""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.during_ramp = P4G_RAW_TX_DURING_RAMP(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_TX_DURING_RAMP
-        """
-        self.time_offset = P4G_RAW_TX_TIME_OFFSET(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_TX_TIME_OFFSET
-        """
-
-
-class GDownloadRequestRaw:
-    """Download request settings."""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.server_must_wait = P4G_RAW_HAS_DOWNLOAD_REQ(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_HAS_DOWNLOAD_REQ
-        """
-        self.transactions_number = P4G_RAW_REQUEST_REPEAT(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_REQUEST_REPEAT
-        """
-        self.content = P4G_RAW_DOWNLOAD_REQUEST(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_DOWNLOAD_REQUEST
-        """
-
-
-class GCountersTransaction:
-    """Transaction counters."""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.transaction = P4G_APP_TRANSACTION_COUNTERS(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_APP_TRANSACTION_COUNTERS
-        """
-
-
-class GRaw:
-    """Raw test application configuration."""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
-        self.test_scenario = P4G_RAW_TEST_SCENARIO(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_TEST_SCENARIO
-        """
-        self.utilization = P4G_RAW_UTILIZATION(conn, module_id, port_id, group_idx)
-        """
-        Representation of P4G_RAW_UTILIZATION
-        """
-        self.download_request = GDownloadRequestRaw(conn, module_id, port_id, group_idx)
-        """Download request."""
-        self.payload = GPayloadRaw(conn, module_id, port_id, group_idx)
-        """Payload configuration."""
-        self.connection = GConnectionRaw(conn, module_id, port_id, group_idx)
-        """Connection configuration."""
-        self.bursty = GBurstyRaw(conn, module_id, port_id, group_idx)
-        """Burst configuration."""
-        self.tx = GTransmitRaw(conn, module_id, port_id, group_idx)
-        """Transmit configuration."""
-
-        self.transaction_counter = GCountersTransaction(conn, module_id, port_id, group_idx)
-        """Transaction counters"""

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"""