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

xoa_driver/internals/hli_v1/ports/port_l23/family_g.py

@@ -1,77 +0,0 @@
-import functools
-from typing import TYPE_CHECKING, Tuple
-from typing import Self
-from xoa_driver.internals.commands import (
-    P_DYNAMIC,
-)
-from xoa_driver.internals.utils import attributes as utils
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-
-from .bases.port_l23_genuine import BasePortL23Genuine
-from .pcs_pma_ghijkl import (
-    PcsPma,
-    SerDes,
-)
-
-
-class FamilyG(BasePortL23Genuine):
-    pcs_pma: PcsPma
-    """PCS/PMA settings.
-        
-    :type: ~xoa_driver.internals.hli_v1.ports.port_l23.pcs_pma_ghijkl.PcsPma
-    """
-    
-    serdes: Tuple[SerDes, ...]
-    """SerDes index
-
-    :type: Tuple[SerDes, ...]
-    """
-
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
-        super().__init__(conn, module_id, port_id)
-        self.dynamic = P_DYNAMIC(conn, module_id, port_id)
-        """L23 port's dynamic traffic change.
-        
-        :type: P_DYNAMIC
-        """
-
-    async def _setup(self) -> Self:
-        await super()._setup()
-        self.serdes = tuple(
-            SerDes(self._conn, *self.kind, serdes_xindex=serdes_xindex)
-            for serdes_xindex in range(self.info.capabilities.serdes_count)
-        )
-        self.pcs_pma = PcsPma(self._conn, self)
-        return self
-
-    on_dynamic_change = functools.partialmethod(utils.on_event, P_DYNAMIC)
-    """Register a callback to the event that the port's dynamic traffic setting changes."""
-
-
-class PLoki100G3S1P(FamilyG):
-    """L23 port on Loki-100G-3S-1P module.
-    """
-    ...
-
-
-class PLoki100G3S1P_b(FamilyG):
-    """L23 port on Loki-100G-3S-1P[b] module.
-    """
-    ...
-
-
-class PLoki100G3S1PSE(FamilyG):
-    """L23 port on Loki-100G-3S-1P-SE module.
-    """
-    ...
-
-class PLoki100G3S1PB(FamilyG):
-    """L23 port on Loki-100G-3S-1P-B module.
-    """
-    ...
-
-class PLoki100G3S1PB_b(FamilyG):
-    """L23 port on Loki-100G-3S-1P-B[b] module.
-    """
-    ...

xoa_driver/internals/hli_v2/indices/base_index.py

@@ -1,39 +0,0 @@
-import abc
-from typing import (
-    List,
-    TypeVar,
-    Type,
-    TYPE_CHECKING,
-)
-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
-
-
-CT = TypeVar("CT")
-
-
-class BaseIndex(abc.ABC):
-    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "observer.IndicesObserver") -> None:
-        self._observer = observer
-        self._conn = conn
-        self.kind = kind
-
-    @property
-    def idx(self) -> int:
-        return self.kind.index_id
-
-    @abc.abstractmethod
-    async def delete(self) -> None:
-        raise NotImplementedError()
-
-    @classmethod
-    @abc.abstractmethod
-    async def _fetch(cls, conn: "itf.IConnection", module_id: int, port_id: int) -> List[int]:
-        raise NotImplementedError()
-
-    @classmethod
-    @abc.abstractmethod
-    async def _new(cls: Type[CT], conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "observer.IndicesObserver") -> CT:
-        raise NotImplementedError()

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