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

xoa_driver/internals/hli_v2/ports/port_l23/bases/port_reception_statistics.py

@@ -1,156 +0,0 @@
-from typing import (
-    TYPE_CHECKING,
-    Dict,
-)
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-
-from xoa_driver.internals.commands import (
-    PR_TPLDJITTER,
-    PR_TOTAL,
-    PR_NOTPLD,
-    PR_EXTRA,
-    PR_TPLDS,
-    PR_TPLDTRAFFIC,
-    PR_TPLDERRORS,
-    PR_TPLDLATENCY,
-    PR_FILTER,
-    PR_CLEAR,
-    PR_PFCSTATS,
-    # genuine only
-    PR_CALIBRATE,
-    PR_UAT_STATUS,
-    PR_UAT_TIME,
-
-)
-
-
-# region All Ports
-
-class PrsTPLD:
-    """L23 port's TPLD traffic statistics."""
-
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, tpld_idx: int) -> None:
-        self.traffic = PR_TPLDTRAFFIC(conn, module_id, port_id, tpld_idx)
-        """L23 port's statistics of traffic with TPLD.
-        Representation of PR_TPLDTRAFFIC
-        """
-
-        self.errors = PR_TPLDERRORS(conn, module_id, port_id, tpld_idx)
-        """L23 port's error statistics of traffic with TPLD.
-        Representation of PR_TPLDERRORS
-        """
-
-        self.latency = PR_TPLDLATENCY(conn, module_id, port_id, tpld_idx)
-        """L23 port's latency statistics of traffic with TPLD.
-        Representation of PR_TPLDLATENCY
-        """
-
-        self.jitter = PR_TPLDJITTER(conn, module_id, port_id, tpld_idx)
-        """L23 port's jitter statistics of traffic with TPLD.
-        Representation of PR_TPLDJITTER
-        """
-
-
-class PortReceptionStatistics:
-    """Port RX statistics"""
-
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
-        self.__conn = conn
-        self.__module_id = module_id
-        self.__port_id = port_id
-
-        self.__tpld_ids = PR_TPLDS(conn, module_id, port_id)
-
-        self.total = PR_TOTAL(conn, module_id, port_id)
-        """L23 port's total traffic statistics.
-        Representation of PR_TOTAL
-        """
-
-        self.no_tpld = PR_NOTPLD(conn, module_id, port_id)
-        """L23 port's statistics of traffic without TPLD.
-        Representation of PR_NOTPLD
-        """
-
-        self.extra = PR_EXTRA(conn, module_id, port_id)
-        """L23 port's extra traffic statistics.
-        Representation of PR_EXTRA
-        """
-        self.pfc_stats = PR_PFCSTATS(conn, module_id, port_id)
-        """L23 port's statistics of received PFC packets.
-        Representation of PR_PFCSTATS
-        """
-        self.clear = PR_CLEAR(conn, module_id, port_id)
-        """Clear all RX statistics on the L23 port.
-        Representation of PR_CLEAR
-        """
-
-    def obtain_filter_statistics(self, filter: int) -> "PR_FILTER":
-        """Obtain L23 port filtered traffic statistics.
-
-        :param filter: index of the filter
-        :type filter: int
-        :return: filtered traffic statistics
-        :rtype: PR_FILTER
-        """
-
-        return PR_FILTER(
-            self.__conn,
-            self.__module_id,
-            self.__port_id,
-            filter
-        )
-
-    def access_tpld(self, tpld_id: int) -> "PrsTPLD":
-        """Access a certain TPLD value on a L23 port.
-
-        :param tpld_id: TPLD value.
-        :type tpld_id: int
-        :return: L23 port's TPLD traffic statistics
-        :rtype: PrsTPLD
-        """
-        return PrsTPLD(self.__conn, self.__module_id, self.__port_id, tpld_id)
-
-    async def obtain_available_tplds(self) -> Dict[int, "PrsTPLD"]:
-        #TODO: need to check use case if this is enough, otherwise to extend by give possibility manually specify indices
-        tplds = await self.__tpld_ids.get()
-        return {
-            idx:
-            PrsTPLD(self.__conn, self.__module_id, self.__port_id, idx)
-            for idx in tplds.test_payload_identifiers
-        }
-
-
-# endregion
-
-# region Genuine Ports
-class GPrsUat():
-    """L23 port UAT info."""
-
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
-        self.status = PR_UAT_STATUS(conn, module_id, port_id)
-        """L23 port UAT status.
-        Representation of PR_UAT_STATUS
-        """
-
-        self.time = PR_UAT_TIME(conn, module_id, port_id)
-        """L23 port number of unavailable seconds.
-        Representation of PR_UAT_TIME
-        """
-
-
-class GenuinePortReceptionStatistics(PortReceptionStatistics):
-    """L23 port RX statistics."""
-
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
-        super().__init__(conn, module_id, port_id)
-        self.calibrate = PR_CALIBRATE(conn, module_id, port_id)
-        """L23 port calibration of latency for received packets.
-        Representation of PR_CALIBRATE
-        """
-
-        self.uat = GPrsUat(conn, module_id, port_id)
-        """L23 port UAT info.
-        """
-
-# endregion

xoa_driver/internals/hli_v2/ports/port_l23/bases/port_transceiver.py

@@ -1,117 +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 (
-    PX_RW,
-    PX_MII,
-    PX_TEMPERATURE,
-    PX_RW_SEQ,
-    PX_I2C_CONFIG,
-    PX_RW_SEQ_BANK,
-)
-
-
-class PortTransceiver:
-    """L23 port transceiver."""
-
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
-        self.__conn = conn
-        self.__module_id = module_id
-        self.__port_id = port_id
-
-        self.i2c_config = PX_I2C_CONFIG(conn, module_id, port_id)
-        """Access speed on a transceiver.
-        :type: PX_I2C_CONFIG
-        """
-
-    def access_temperature(self):
-        """Transceiver temperature in Celsius.
-
-        :return: Transceiver temperature integral and decimal parts
-        :rtype: PX_TEMPERATURE
-        """
-
-        return PX_TEMPERATURE(
-            self.__conn,
-            self.__module_id,
-            self.__port_id,
-        )
-
-    def access_rw(self, page_address: int, register_address: int) -> "PX_RW":
-        """Access to register interface by the transceiver.
-
-        :param page_address: page address
-        :type page_address: int
-        :param register_address: register address
-        :type register_address: int
-        :return: transceiver register values
-        :rtype: PX_RW
-        """
-
-        return PX_RW(
-            self.__conn,
-            self.__module_id,
-            self.__port_id,
-            page_address,
-            register_address
-        )
-
-    def access_mii(self, register_address: int) -> "PX_MII":
-        """Access to the register interface supported by the media-independent interface (MII) transceiver.
-
-        :param register_address: register address
-        :type register_address: int
-        :return: register values
-        :rtype: PX_MII
-        """
-        return PX_MII(
-            self.__conn,
-            self.__module_id,
-            self.__port_id,
-            register_address
-        )
-
-    def access_rw_seq(self, page_address: int, register_address: int, byte_count: int) -> "PX_RW_SEQ":
-        """Sequential read/write a number of bytes to the register interface supported by the media-independent interface (MII) transceiver.
-
-        :param page_address: page address (0-255)
-        :type page_address: int
-        :param register_address: register address (0-255)
-        :type register_address: int
-        :param byte_count: the number of bytes to read/write
-        :type byte_count: int
-        :return: transceiver register values
-        :rtype: PX_RW_SEQ
-        """
-        return PX_RW_SEQ(
-            self.__conn,
-            self.__module_id,
-            self.__port_id,
-            page_address,
-            register_address,
-            byte_count
-        )
-
-    def access_rw_seq_bank(self, bank_address: int, page_address: int, register_address: int, byte_count: int) -> "PX_RW_SEQ_BANK":
-        """Sequential read/write a number of bytes to the register interface supported by the media-independent interface (MII) transceiver.
-
-        :param bank_address: bank address (0-255)
-        :type bank_address: int
-        :param page_address: page address (0-255)
-        :type page_address: int
-        :param register_address: register address (0-255)
-        :type register_address: int
-        :param byte_count: the number of bytes to read/write
-        :type byte_count: int
-        :return: transceiver register values
-        :rtype: PX_RW_SEQ_BANK
-        """
-        return PX_RW_SEQ_BANK(
-            self.__conn,
-            self.__module_id,
-            self.__port_id,
-            bank_address,
-            page_address,
-            register_address,
-            byte_count
-        )

xoa_driver/internals/hli_v2/ports/port_l23/bases/port_transmission_statistics.py

@@ -1,59 +0,0 @@
-from typing import (
-    TYPE_CHECKING,
-    Union,
-)
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-    from xoa_driver.internals.hli_v2.indices.streams.genuine_stream import GenuineStreamIdx
-from xoa_driver.internals.commands import (
-    PT_TOTAL,
-    PT_NOTPLD,
-    PT_STREAM,
-    PT_CLEAR,
-    PT_EXTRA,
-)
-
-
-class PortTransmissionStatistics:
-    """L23 port TX statistics"""
-
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
-        self.__conn = conn
-        self.__module_id = module_id
-        self.__port_id = port_id
-        self.total = PT_TOTAL(conn, module_id, port_id)
-        """All TX statistics on the L23 port.
-        Representation of PT_TOTAL
-        """
-
-        self.extra = PT_EXTRA(conn, module_id, port_id)
-        """Extra TX statistics on the L23 port.
-        Representation of PT_EXTRA
-        """
-
-        self.no_tpld = PT_NOTPLD(conn, module_id, port_id)
-        """TX statistics of packets without TPLD on the L23 port.
-        Representation of PT_NOTPLD
-        """
-
-        self.clear = PT_CLEAR(conn, module_id, port_id)
-        """Clear TX statistics on the L23 port.
-        Representation of PT_CLEAR
-        """
-
-    def obtain_from_stream(self, stream: Union[int, "GenuineStreamIdx"]) -> "PT_STREAM":
-        """Obtain statistics of packets of a specific stream on a L23 port.
-
-        :param stream: stream object
-        :type stream: Union[int, "GenuineStreamIdx"]
-        :return: statistics of packets of a specific stream on a L23 port
-        :rtype: PT_STREAM
-        """
-
-        stream_idx = stream if isinstance(stream, int) else stream.kind.index_id
-        return PT_STREAM(
-            self.__conn,
-            self.__module_id,
-            self.__port_id,
-            stream_idx
-        )

xoa_driver/internals/hli_v2/ports/port_l23/chimera/filter_definition/_utils.py

@@ -1,15 +0,0 @@
-from typing import NoReturn, TypeVar
-from xoa_driver.internals.commands.enums import FilterType
-
-T = TypeVar("T")
-
-
-def prevent_set(inst: T, filter_type: FilterType = FilterType.WORKING) -> T:
-    METHOD_NAME = "set"
-
-    def _set(*args, **kwargs) -> NoReturn:
-        raise Exception(f"Method {METHOD_NAME} is not allowed")
-
-    if filter_type is FilterType.WORKING and hasattr(inst, METHOD_NAME):
-        setattr(inst, METHOD_NAME, _set)
-    return inst

xoa_driver/internals/hli_v2/ports/port_l23/chimera/filter_definition/general.py

@@ -1,340 +0,0 @@
-from typing import (
-    Dict,
-    Tuple,
-    Type,
-    TypeVar,
-    TYPE_CHECKING
-)
-if TYPE_CHECKING:
-    from xoa_driver.internals.core import interfaces as itf
-from xoa_driver.internals.commands.enums import (
-    FilterType,
-    FilterVlanType,
-    ProtocolOption,
-    FilterMode,
-)
-from xoa_driver.internals.commands import (
-    PEF_ETHSETTINGS,
-    PEF_ETHSRCADDR,
-    PEF_ETHDESTADDR,
-    PEF_L2PUSE,
-    PEF_VLANSETTINGS,
-    PEF_VLANTAG,
-    PEF_VLANPCP,
-    PEF_MPLSSETTINGS,
-    PEF_MPLSLABEL,
-    PEF_MPLSTOC,
-    PEF_L3USE,
-    PEF_IPV4SETTINGS,
-    PEF_IPV4SRCADDR,
-    PEF_IPV4DESTADDR,
-    PEF_IPV4DSCP,
-    PEF_IPV6SETTINGS,
-    PEF_IPV6SRCADDR,
-    PEF_IPV6DESTADDR,
-    PEF_IPV6TC,
-    PEF_UDPSETTINGS,
-    PEF_UDPSRCPORT,
-    PEF_UDPDESTPORT,
-    PEF_TCPSETTINGS,
-    PEF_TCPSRCPORT,
-    PEF_TCPDESTPORT,
-    PEF_ANYSETTINGS,
-    PEF_ANYCONFIG,
-    PEF_TPLDSETTINGS,
-    PEF_TPLDCONFIG,
-    # PEF_ISSHADOWDIRTY, #TODO: need to implement
-    # PEF_CANCEL, #TODO: need to implement
-    PEF_VALUE,
-    PEF_MASK,
-    PEF_PROTOCOL,
-    PEF_MODE,
-)
-from ._utils import prevent_set
-
-
-class FEthernet:
-    """Filter for Ethernet field."""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
-        self.settings = prevent_set(PEF_ETHSETTINGS(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """Filter action on Ethernet field.
-        Representation of PEF_ETHSETTINGS
-        """
-        self.src_address = prevent_set(PEF_ETHSRCADDR(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """Ethernet source address settings for the filter.
-        Representation of PEF_ETHSRCADDR
-        """
-        self.dest_address = prevent_set(PEF_ETHDESTADDR(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """Ethernet destination address settings for the filter.
-        Representation of PEF_ETHDESTADDR
-        """
-
-
-class FPerVlanType:
-    """Filter for VLAN tag."""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType, vlan_type: FilterVlanType) -> None:
-        self.tag = prevent_set(PEF_VLANTAG(conn, module_id, port_id, flow_index, filter_type, vlan_type), filter_type)
-        """VLAN tag setting for the filter.
-        Representation of PEF_VLANTAG
-        """
-        self.pcp = prevent_set(PEF_VLANPCP(conn, module_id, port_id, flow_index, filter_type, vlan_type), filter_type)
-        """VLAN PCP setting for the filter.
-        Representation of PEF_VLANPCP
-        """
-
-
-class FVlan:
-    """Filter for VLAN field."""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
-        self.settings = prevent_set(PEF_VLANSETTINGS(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """Filter action on VLAN field.
-        Representation of PEF_VLANSETTINGS
-        """
-
-        self.inner = FPerVlanType(conn, module_id, port_id, flow_index, filter_type, FilterVlanType.INNER)
-        """Filter for inner VLAN tag."""
-
-        self.outer = FPerVlanType(conn, module_id, port_id, flow_index, filter_type, FilterVlanType.OUTER)
-        """Filter for outer VLAN tag."""
-
-
-class FUdp:
-    """Filer for UDP field."""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
-        self.settings = prevent_set(PEF_UDPSETTINGS(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """Filter action on UDP field.
-        Representation of PEF_UDPSETTINGS
-        """
-        self.src_port = prevent_set(PEF_UDPSRCPORT(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """UDP source port settings for the filter.
-        Representation of PEF_UDPSRCPORT
-        """
-        self.dest_port = prevent_set(PEF_UDPDESTPORT(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """UDP destination port settings for the filter.
-        Representation of PEF_UDPDESTPORT
-        """
-
-
-class FTcp:
-    """Filter for TCP."""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
-        self.settings = prevent_set(PEF_TCPSETTINGS(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """Filter action on TCP field.
-        Representation of PEF_TCPSETTINGS
-        """
-        self.src_port = prevent_set(PEF_TCPSRCPORT(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """TCP source port settings for the filter.
-        Representation of PEF_TCPSRCPORT
-        """
-        self.dest_port = prevent_set(PEF_TCPDESTPORT(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """TCP destination port settings for the filter.
-        Representation of PEF_TCPDESTPORT
-        """
-
-
-class FIPv4:
-    """Filter for IPv4 field."""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
-        self.settings = prevent_set(PEF_IPV4SETTINGS(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """Filter action on IPv4 field.
-        Representation of PEF_IPV4SETTINGS
-        """
-        self.src_address = prevent_set(PEF_IPV4SRCADDR(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """IPv4 source address settings for the filter.
-        Representation of PEF_IPV4SRCADDR
-        """
-        self.dest_address = prevent_set(PEF_IPV4DESTADDR(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """IPv4 destination address settings for the filter.
-        Representation of PEF_IPV4DESTADDR
-        """
-        self.dscp = prevent_set(PEF_IPV4DSCP(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """IPv4 DSCP/TOS settings for the filter.
-        Representation of PEF_IPV4DSCP
-        """
-
-
-class FIPv6:
-    """Filter for IPv6 field."""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
-        self.settings = prevent_set(PEF_IPV6SETTINGS(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """Filter action on IPv6 field.
-        Representation of PEF_IPV6SETTINGS
-        """
-        self.src_address = prevent_set(PEF_IPV6SRCADDR(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """IPv6 source address settings for the filter.
-        Representation of PEF_IPV6SRCADDR
-        """
-        self.dest_address = prevent_set(PEF_IPV6DESTADDR(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """IPv6 destination address settings for the filter.
-        Representation of PEF_IPV6DESTADDR
-        """
-        self.traffic_class = prevent_set(PEF_IPV6TC(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """IPv6 traffic class settings for the filter.
-        Representation of PEF_IPV6TC
-        """
-
-
-class FIp:
-    """Filter for IP field."""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
-        self.v4 = FIPv4(conn, module_id, port_id, flow_index, filter_type)
-        """Filter for IPv4 field."""
-
-        self.v6 = FIPv6(conn, module_id, port_id, flow_index, filter_type)
-        """Filter for IPv6 field."""
-
-
-class FMpls:
-    """Filter for MPLS field."""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
-        self.settings = prevent_set(PEF_MPLSSETTINGS(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """Filter action on MPLS field.
-        Representation of PEF_MPLSSETTINGS
-        """
-        self.label = prevent_set(PEF_MPLSLABEL(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """MPLS label settings for the filter.
-        Representation of PEF_MPLSLABEL
-        """
-        self.toc = prevent_set(PEF_MPLSTOC(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """"MPLS TOC settings for the filter.
-        Representation of PEF_MPLSTOC
-        """
-
-
-class FTpld:
-    """Filter for Xena TPLD field."""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
-        self.settings = prevent_set(PEF_TPLDSETTINGS(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """Filter action on Xena TPLD field.
-        Representation of PEF_TPLDSETTINGS
-        """
-
-        self.test_payload_filters_config = tuple(
-            prevent_set(PEF_TPLDCONFIG(conn, module_id, port_id, flow_index, filter_type, test_payload_filter_index), filter_type)
-            for test_payload_filter_index in range(16)  # range need to put to the constants place
-        )
-        """TPLD filter configurations.
-        Representation of PEF_TPLDCONFIG
-        """
-
-
-class FAny:
-    """Filter for any field."""
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
-        self.settings = prevent_set(PEF_ANYSETTINGS(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """Filter action on any field.
-        Representation of PEF_ANYSETTINGS
-        """
-        self.config = prevent_set(PEF_ANYCONFIG(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """Any field's filter configurations.
-        Representation of PEF_ANYCONFIG
-        """
-
-
-class ModeBasic:
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
-        self.l2plus_use = prevent_set(PEF_L2PUSE(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """L2 protocol to use.
-        Representation of PEF_L2PUSE
-        """
-        self.l3_use = prevent_set(PEF_L3USE(conn, module_id, port_id, flow_index, filter_type), filter_type)
-        """L3 protocol to use.
-        Representation of PEF_L3USE
-        """
-        self.any = FAny(conn, module_id, port_id, flow_index, filter_type)
-        """Filter for any field."""
-
-        self.tpld = FTpld(conn, module_id, port_id, flow_index, filter_type)
-        """Filter for Xena TPLD field."""
-
-        self.mpls = FMpls(conn, module_id, port_id, flow_index, filter_type)
-        """Filter for MPLS field."""
-
-        self.ip = FIp(conn, module_id, port_id, flow_index, filter_type)
-        """Filter for IP field."""
-
-        self.tcp = FTcp(conn, module_id, port_id, flow_index, filter_type)
-        """Filter for TCP field."""
-
-        self.udp = FUdp(conn, module_id, port_id, flow_index, filter_type)
-        """Filter for UDP field."""
-
-        self.vlan = FVlan(conn, module_id, port_id, flow_index, filter_type)
-        """Filter for VLAN field."""
-
-        self.ethernet = FEthernet(conn, module_id, port_id, flow_index, filter_type)
-        """Filter for Ethernet field."""
-
-
-class ProtocolSegment:
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType, protocol_segment_index: int, segment_type: ProtocolOption) -> None:  # noqa: E501
-        self.segment_type = segment_type
-
-        self.value = prevent_set(PEF_VALUE(conn, module_id, port_id, flow_index, filter_type, protocol_segment_index), filter_type)
-        """Value bytes match for the filter.
-        Representation of PEF_VALUE
-        """
-        self.mask = prevent_set(PEF_MASK(conn, module_id, port_id, flow_index, filter_type, protocol_segment_index), filter_type)
-        """Mask byte value.
-        Representation of PEF_MASK
-        """
-
-
-class ModeExtended:
-    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
-        self._conn = conn
-        self._module_id = module_id
-        self._port_id = port_id
-        self._flow_index = flow_index
-        self._filter_type = filter_type
-
-        # self.protocol = prevent_set(PEF_PROTOCOL(conn, module_id, port_id, flow_index, filter_type))
-        # """Protocol segments match for the filter.
-        # Representation of PEF_PROTOCOL
-        # """
-
-    async def get_protocol_segments(self) -> Tuple[ProtocolSegment, ...]:
-        segments_raw = (
-            await PEF_PROTOCOL(
-                self._conn,
-                self._module_id,
-                self._port_id,
-                self._flow_index,
-                self._filter_type
-            ).get()
-        ).segment_list
-        return tuple(
-            ProtocolSegment(
-                self._conn,
-                self._module_id,
-                self._port_id,
-                self._flow_index,
-                self._filter_type,
-                idx + 1,  # TODO: need to discuss with Leo
-                ProtocolOption(segment_type)
-            )
-            for idx, segment_type in enumerate(segments_raw)
-        )
-
-
-T = TypeVar("T")
-
-
-async def get_mode(conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType, mode_types: Dict[FilterMode, Type[T]]) -> T:
-    mode_raw = (
-        await PEF_MODE(
-            conn,
-            module_id,
-            port_id,
-            flow_index,
-            filter_type,
-        ).get()
-    ).mode
-    mode_type = mode_types[FilterMode(mode_raw)]
-    return mode_type(
-        conn,
-        module_id,
-        port_id,
-        flow_index,
-        filter_type,
-    )