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

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

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

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

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

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

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