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

xoa_driver/internals/commands/pl1_commands.py

@@ -832,7 +832,16 @@ class PL1_PRESET_CONFIG_COEFF:
 @dataclass
 class PL1_PHYTXEQ_LEVEL:
     """
-    Control and monitor the equalizer settings of the on-board PHY in the transmission direction (towards the transceiver cage).
+    Control and monitor the equalizer settings (mV/dB values) of the on-board PHY in the transmission direction (towards the transceiver cage).
+
+    This command returns a variable number of tap values with module-dependent ordering:
+
+    - **Regular Freya**: Original fixed format [pre3, pre2, pre, main, post]
+    - **Loki-4P and H-Freya/Edun**: Variable number in N*pre, main, M*post layout
+      [pre_n, pre_n-1, ..., pre_1, main, post_1, post_2, ..., post_m]
+
+    Use P_CAPABILITIES to query ``numtxeqtaps`` and ``numtxeqpretaps`` to determine
+    the number of taps and layout.
 
     .. note::
 
@@ -849,44 +858,63 @@ class PL1_PHYTXEQ_LEVEL:
     _serdes_xindex: int
 
     class GetDataAttr(ResponseBodyStruct):
-        pre3: int = field(XmpInt())
-        """integer, pre3 tap value in dB/10, ranges from 0 to 71. Default = 0 (neutral)"""
-        pre2: int = field(XmpInt())
-        """integer, pre2 tap value in dB/10, ranges from 0 to 71. Default = 0 (neutral)"""
-        pre: int = field(XmpInt())
-        """integer, pre tap value in dB/10, ranges from 0 to 187. Default = 0 (neutral)"""
-        main: int = field(XmpInt())
-        """integer, main tap value in mV, ranges from 507 to 998."""
-        post: int = field(XmpInt())
-        """integer, post tap value in dB/10, ranges from 0 to 187 Default = 0 (neutral)"""
-        
+        tap_values: typing.List[int] = field(XmpSequence(types_chunk=[XmpInt()]))
+        """list of integers, TX EQ tap values in mV/dB. The number and layout depend on the platform:
+
+        - Regular Freya: [pre3, pre2, pre, main, post] where pre3/pre2 in dB/10 (0-71), pre/post in dB/10 (0-187), main in mV (507-998)
+        - Loki-4P and H-Freya/Edun: [pre_n, ..., pre_1, main, post_1, post_2, ..., post_m]
+          where N = numtxeqpretaps and M = numtxeqtaps - numtxeqpretaps - 1
+        """
+
     class SetDataAttr(RequestBodyStruct):
-        pre3: int = field(XmpInt())
-        """integer, pre3 tap value in dB/10, ranges from 0 to 71. Default = 0 (neutral)"""
-        pre2: int = field(XmpInt())
-        """integer, pre2 tap value in dB/10, ranges from 0 to 71. Default = 0 (neutral)"""
-        pre: int = field(XmpInt())
-        """integer, pre tap value in dB/10, ranges from 0 to 187. Default = 0 (neutral)"""
-        main: int = field(XmpInt())
-        """integer, main tap value in mV, ranges from 507 to 998."""
-        post: int = field(XmpInt())
-        """integer, post tap value in dB/10, ranges from 0 to 187 Default = 0 (neutral)"""
+        tap_values: typing.List[int] = field(XmpSequence(types_chunk=[XmpInt()]))
+        """list of integers, TX EQ tap values in mV/dB. The number and layout depend on the platform:
+
+        - Regular Freya: [pre3, pre2, pre, main, post] where pre3/pre2 in dB/10 (0-71), pre/post in dB/10 (0-187), main in mV (507-998)
+        - Loki-4P and H-Freya/Edun: [pre_n, ..., pre_1, main, post_1, post_2, ..., post_m]
+          where N = numtxeqpretaps and M = numtxeqtaps - numtxeqpretaps - 1
+        """
 
     def get(self) -> Token[GetDataAttr]:
+        """Get the TX equalizer settings (mV/dB values) of the on-board PHY.
+
+        The returned tap values layout depends on the platform. Query P_CAPABILITIES
+        for ``numtxeqtaps`` and ``numtxeqpretaps`` to determine the format.
+
+        :return: list of TX EQ tap values in mV/dB
+        :rtype: PL1_PHYTXEQ_LEVEL.GetDataAttr
+        """
 
         return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._serdes_xindex]))
 
-    def set(self, pre3:int, pre2: int, pre: int, main: int, post: int) -> Token[None]:
+    def set(self, tap_values: typing.List[int]) -> Token[None]:
+        """Set the TX equalizer settings (mV/dB values) of the on-board PHY.
+
+        The tap values layout depends on the platform. Query P_CAPABILITIES
+        for ``numtxeqtaps`` and ``numtxeqpretaps`` to determine the required format.
+
+        :param tap_values: list of TX EQ tap values in mV/dB in platform-specific order
+        :type tap_values: typing.List[int]
+        """
 
         return Token(
             self._connection,
-            build_set_request(self, module=self._module, port=self._port, indices=[self._serdes_xindex], pre3=pre3, pre2=pre2, pre=pre, main=main, post=post))
-    
+            build_set_request(self, module=self._module, port=self._port, indices=[self._serdes_xindex], tap_values=tap_values))
+
 @register_command
 @dataclass
 class PL1_PHYTXEQ_COEFF:
     """
-    Control and monitor the equalizer settings of the on-board PHY in the transmission direction (towards the transceiver cage).
+    Control and monitor the equalizer settings (IEEE coefficient values) of the on-board PHY in the transmission direction (towards the transceiver cage).
+
+    This command returns a variable number of tap values with module-dependent ordering:
+
+    - **Regular Freya**: Original fixed format [pre3, pre2, pre, main, post]
+    - **Loki-4P and H-Freya/Edun**: Variable number in N*pre, main, M*post layout
+      [pre_n, pre_n-1, ..., pre_1, main, post_1, post_2, ..., post_m]
+
+    Use P_CAPABILITIES to query ``numtxeqtaps`` and ``numtxeqpretaps`` to determine
+    the number of taps and layout.
 
     .. note::
 
@@ -913,38 +941,48 @@ class PL1_PHYTXEQ_COEFF:
     _serdes_xindex: int
 
     class GetDataAttr(ResponseBodyStruct):
-        pre3: int = field(XmpInt())
-        """integer, pre3 tap value, negative, scaled by 1E3. Default = 0 (neutral)"""
-        pre2: int = field(XmpInt())
-        """integer, pre2 tap value, positive, scaled by 1E3. Default = 0 (neutral)"""
-        pre: int = field(XmpInt())
-        """integer, pre tap value, negative, scaled by 1E3. Default = 0 (neutral)"""
-        main: int = field(XmpInt())
-        """integer, main tap value, positive, scaled by 1E3. Default = 1000"""
-        post: int = field(XmpInt())
-        """integer, post tap value, negative, scaled by 1E3. Default = 0 (neutral)"""
-        
+        tap_values: typing.List[int] = field(XmpSequence(types_chunk=[XmpInt()]))
+        """list of integers, TX EQ tap values as IEEE coefficients scaled by 1E3. The number and layout depend on the platform:
+
+        - Regular Freya: [pre3, pre2, pre, main, post] where pre3/pre/post are negative, pre2/main are positive
+        - Loki-4P and H-Freya/Edun: [pre_n, ..., pre_1, main, post_1, ..., post_m]
+          where N = numtxeqpretaps and M = numtxeqtaps - numtxeqpretaps - 1
+        """
+
     class SetDataAttr(RequestBodyStruct):
-        pre3: int = field(XmpInt())
-        """integer, pre3 tap value, negative, scaled by 1E3. Default = 0 (neutral)"""
-        pre2: int = field(XmpInt())
-        """integer, pre2 tap value, positive, scaled by 1E3. Default = 0 (neutral)"""
-        pre: int = field(XmpInt())
-        """integer, pre tap value, negative, scaled by 1E3. Default = 0 (neutral)"""
-        main: int = field(XmpInt())
-        """integer, main tap value, positive, scaled by 1E3. Default = 1000"""
-        post: int = field(XmpInt())
-        """integer, post tap value, negative, scaled by 1E3. Default = 0 (neutral)"""
+        tap_values: typing.List[int] = field(XmpSequence(types_chunk=[XmpInt()]))
+        """list of integers, TX EQ tap values as IEEE coefficients scaled by 1E3. The number and layout depend on the platform:
+
+        - Regular Freya: [pre3, pre2, pre, main, post] where pre3/pre/post are negative, pre2/main are positive
+        - Loki-4P and H-Freya/Edun: [pre_n, ..., pre_1, main, post_1, ..., post_m]
+          where N = numtxeqpretaps and M = numtxeqtaps - numtxeqpretaps - 1
+        """
 
     def get(self) -> Token[GetDataAttr]:
+        """Get the TX equalizer settings (IEEE coefficient values) of the on-board PHY.
+
+        The returned tap values layout depends on the platform. Query P_CAPABILITIES
+        for ``numtxeqtaps`` and ``numtxeqpretaps`` to determine the format.
+
+        :return: list of TX EQ tap values as IEEE coefficients scaled by 1E3
+        :rtype: PL1_PHYTXEQ_COEFF.GetDataAttr
+        """
 
         return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._serdes_xindex]))
 
-    def set(self, pre3:int, pre2: int, pre: int, main: int, post: int) -> Token[None]:
+    def set(self, tap_values: typing.List[int]) -> Token[None]:
+        """Set the TX equalizer settings (IEEE coefficient values) of the on-board PHY.
+
+        The tap values layout depends on the platform. Query P_CAPABILITIES
+        for ``numtxeqtaps`` and ``numtxeqpretaps`` to determine the required format.
+
+        :param tap_values: list of TX EQ tap values as IEEE coefficients scaled by 1E3 in platform-specific order
+        :type tap_values: typing.List[int]
+        """
 
         return Token(
             self._connection,
-            build_set_request(self, module=self._module, port=self._port, indices=[self._serdes_xindex], pre3=pre3, pre2=pre2, pre=pre, main=main, post=post))    
+            build_set_request(self, module=self._module, port=self._port, indices=[self._serdes_xindex], tap_values=tap_values))
 
 @register_command
 @dataclass
@@ -1345,7 +1383,16 @@ class PL1_ANLT:
 @dataclass
 class PL1_PHYTXEQ:
     """
-    Control and monitor the equalizer settings of the on-board PHY in the transmission direction (towards the transceiver cage).
+    Control and monitor the equalizer settings (native values) of the on-board PHY in the transmission direction (towards the transceiver cage).
+
+    This command returns a variable number of tap values with module-dependent ordering:
+
+    - **Regular Freya**: Original fixed format [pre3, pre2, pre, main, post]
+    - **Loki-4P and H-Freya/Edun**: Variable number in N*pre, main, M*post layout
+      [pre_n, pre_n-1, ..., pre_1, main, post_1, post_2, ..., post_m]
+
+    Use P_CAPABILITIES to query ``numtxeqtaps`` and ``numtxeqpretaps`` to determine
+    the number of taps and layout.
 
     .. note::
 
@@ -1362,38 +1409,48 @@ class PL1_PHYTXEQ:
     _serdes_xindex: int
 
     class GetDataAttr(ResponseBodyStruct):
-        pre3: int = field(XmpInt())
-        """integer, pre3 tap value. Default = 0 (neutral)"""
-        pre2: int = field(XmpInt())
-        """integer, pre2 tap value. Default = 0 (neutral)"""
-        pre: int = field(XmpInt())
-        """integer, pre tap value. Default = 0 (neutral)"""
-        main: int = field(XmpInt())
-        """integer, main tap value."""
-        post: int = field(XmpInt())
-        """integer, post tap value. Default = 0 (neutral)"""
-        
+        tap_values: typing.List[int] = field(XmpSequence(types_chunk=[XmpInt()]))
+        """list of integers, TX EQ tap values (native values). The number and layout depend on the platform:
+
+        - Regular Freya: [pre3, pre2, pre, main, post]
+        - Loki-4P and H-Freya/Edun: [pre_n, ..., pre_1, main, post_1, ..., post_m]
+          where N = numtxeqpretaps and M = numtxeqtaps - numtxeqpretaps - 1
+        """
+
     class SetDataAttr(RequestBodyStruct):
-        pre3: int = field(XmpInt())
-        """integer, pre3 tap value. Default = 0 (neutral)"""
-        pre2: int = field(XmpInt())
-        """integer, pre2 tap value. Default = 0 (neutral)"""
-        pre: int = field(XmpInt())
-        """integer, pre tap value. Default = 0 (neutral)"""
-        main: int = field(XmpInt())
-        """integer, main tap value."""
-        post: int = field(XmpInt())
-        """integer, post tap value. Default = 0 (neutral)"""
+        tap_values: typing.List[int] = field(XmpSequence(types_chunk=[XmpInt()]))
+        """list of integers, TX EQ tap values (native values). The number and layout depend on the platform:
+
+        - Regular Freya: [pre3, pre2, pre, main, post]
+        - Loki-4P and H-Freya/Edun: [pre_n, ..., pre_1, main, post_1, ..., post_m]
+          where N = numtxeqpretaps and M = numtxeqtaps - numtxeqpretaps - 1
+        """
 
     def get(self) -> Token[GetDataAttr]:
+        """Get the TX equalizer settings (native values) of the on-board PHY.
+
+        The returned tap values layout depends on the platform. Query P_CAPABILITIES
+        for ``numtxeqtaps`` and ``numtxeqpretaps`` to determine the format.
+
+        :return: list of TX EQ tap values (native values)
+        :rtype: PL1_PHYTXEQ.GetDataAttr
+        """
 
         return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._serdes_xindex]))
 
-    def set(self, pre3:int, pre2: int, pre: int, main: int, post: int) -> Token[None]:
+    def set(self, tap_values: typing.List[int]) -> Token[None]:
+        """Set the TX equalizer settings (native values) of the on-board PHY.
+
+        The tap values layout depends on the platform. Query P_CAPABILITIES
+        for ``numtxeqtaps`` and ``numtxeqpretaps`` to determine the required format.
+
+        :param tap_values: list of TX EQ tap values (native values) in platform-specific order
+        :type tap_values: typing.List[int]
+        """
 
         return Token(
             self._connection,
-            build_set_request(self, module=self._module, port=self._port, indices=[self._serdes_xindex], pre3=pre3, pre2=pre2, pre=pre, main=main, post=post))
+            build_set_request(self, module=self._module, port=self._port, indices=[self._serdes_xindex], tap_values=tap_values))
 
 @register_command
 @dataclass

xoa_driver/internals/commands/pp_commands.py

@@ -595,7 +595,7 @@ class PP_PMAERRPUL_PARAMS:
     def set(self, duration: int, period: int, repetition: int, coeff: int, exp: int) -> Token[None]:
         """Set PMA pulse error injection settings.
 
-        :param duration: 0 ms - 5000m s; increments of 1 ms; 0 = constant BER
+        :param duration: 0 ms - 5000 ms; increments of 1 ms; 0 = constant BER
         :type duration: int
         :param period: 10 ms - 50000 ms; number of ms - must be multiple of 10 ms
         :type period: int
@@ -1117,7 +1117,19 @@ class PP_EYEINFO:
 class PP_PHYTXEQ:
     """
     Control and monitor the equalizer settings of the on-board PHY in the
-    transmission direction (towards the transceiver cage) on Thor and Loki modules.
+    transmission direction (towards the transceiver cage).
+
+    This command returns a variable number of tap values with module-dependent ordering:
+
+    - **Legacy Loki-2P/Thor**: Original fixed format [pre, main, post, pre2, pre3, mode]
+    - **Regular Freya**: Original fixed format [pre, main, post, pre2, pre3, mode]
+    - **Loki-4P and H-Freya/Edun**: Variable number in N*pre, main, M*post layout
+      [pre_n, pre_n-1, ..., pre_1, main, post_1, post_2, ..., post_m]
+
+    Use P_CAPABILITIES to query ``numtxeqtaps`` and ``numtxeqpretaps`` to determine
+    the number of taps and layout:
+    - ``numtxeqpretaps``: Number of precursor taps (N)
+    - ``numtxeqtaps - numtxeqpretaps - 1``: Number of postcursor taps (M)
 
     .. versionchanged:: 1.1
 
@@ -1132,63 +1144,46 @@ class PP_PHYTXEQ:
     _serdes_xindex: int
 
     class GetDataAttr(ResponseBodyStruct):
-        pre: int = field(XmpInt())
-        """integer, preemphasis, (range: Module dependent), default = 0 (neutral)."""
-        main: int = field(XmpInt())
-        """integer, amplification, (range: Module dependent), default = 0 (neutral)."""
-        post: int = field(XmpInt())
-        """integer, postemphasis, (range: Module dependent), default = 0 (neutral)."""
-        pre2: int = field(XmpInt())
-        """integer, preemphasis, (range: Module dependent), default = 0 (neutral)."""
-        pre3_post2: int = field(XmpInt())
-        """integer, postemphasis, (range: Module dependent), default = 0 (neutral)."""
-        post3: int = field(XmpInt())
-        """integer, postemphasis, (range: Module dependent), default = 0 (neutral)."""
-        mode: int = field(XmpInt())
-        """integer, value must be 4"""
+        tap_values: typing.List[int] = field(XmpSequence(types_chunk=[XmpInt()]))
+        """list of integers, TX EQ tap values. The number and layout depend on the platform:
+
+        - Legacy Loki-2P/Thor and Regular Freya: [pre, main, post, pre2, pre3, mode]
+        - Loki-4P and H-Freya/Edun: [pre_n, ..., pre_1, main, post_1, ..., post_m]
+          where N = numtxeqpretaps and M = numtxeqtaps - numtxeqpretaps - 1
+        """
 
     class SetDataAttr(RequestBodyStruct):
-        pre: int = field(XmpInt())
-        """integer, preemphasis, (range: Module dependent), default = 0 (neutral)."""
-        main: int = field(XmpInt())
-        """integer, amplification, (range: Module dependent), default = 0 (neutral)."""
-        post: int = field(XmpInt())
-        """integer, postemphasis, (range: Module dependent), default = 0 (neutral)."""
-        pre2: int = field(XmpInt())
-        """integer, preemphasis, (range: Module dependent), default = 0 (neutral)."""
-        pre3_post2: int = field(XmpInt())
-        """integer, postemphasis, (range: Module dependent), default = 0 (neutral)."""
-        post3: int = field(XmpInt())
-        """integer, postemphasis, (range: Module dependent), default = 0 (neutral)."""
-        mode: int = field(XmpInt())
-        """integer, value must be 4"""
+        tap_values: typing.List[int] = field(XmpSequence(types_chunk=[XmpInt()]))
+        """list of integers, TX EQ tap values. The number and layout depend on the platform:
+
+        - Legacy Loki-2P/Thor and Regular Freya: [pre, main, post, pre2, pre3, mode]
+        - Loki-4P and H-Freya/Edun: [pre_n, ..., pre_1, main, post_1, ..., post_m]
+          where N = numtxeqpretaps and M = numtxeqtaps - numtxeqpretaps - 1
+        """
 
     def get(self) -> Token[GetDataAttr]:
-        """Get the equalizer settings of the on-board PHY in the
-        transmission direction (towards the transceiver cage) on Thor and Loki modules.
+        """Get the TX equalizer settings of the on-board PHY.
+
+        The returned tap values layout depends on the platform. Query P_CAPABILITIES
+        for ``numtxeqtaps`` and ``numtxeqpretaps`` to determine the format.
 
-        :return: preemphasis, (range: Module dependent), default = 0 (neutral).
+        :return: list of TX EQ tap values
         :rtype: PP_PHYTXEQ.GetDataAttr
         """
 
         return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._serdes_xindex]))
 
-    def set(self, pre2: int, pre: int, main: int, post: int, pre3_post2: int, post3: int) -> Token[None]:
-        """Set the equalizer settings of the on-board PHY in the
-        transmission direction (towards the transceiver cage) on Thor and Loki modules.
+    def set(self, tap_values: typing.List[int]) -> Token[None]:
+        """Set the TX equalizer settings of the on-board PHY.
+
+        The tap values layout depends on the platform. Query P_CAPABILITIES
+        for ``numtxeqtaps`` and ``numtxeqpretaps`` to determine the required format:
+
+        - Legacy Loki-2P/Thor and Regular Freya: [pre, main, post, pre2, pre3, mode]
+        - Loki-4P and H-Freya/Edun: [pre_n, ..., pre_1, main, post_1, ..., post_m]
 
-        :param pre2: pre2 emphasis
-        :type pre2: int
-        :param pre: pre emphasis
-        :type pre: int
-        :param main: main emphasis
-        :type main: int
-        :param post: post emphasis
-        :type post: int
-        :param pre3_post2: post2 or pre3 emphasis
-        :type pre3_post2: int
-        :param post3: post3 emphasis
-        :type post3: int
+        :param tap_values: list of TX EQ tap values in platform-specific order
+        :type tap_values: typing.List[int]
         """
 
         return Token(
@@ -1198,13 +1193,7 @@ class PP_PHYTXEQ:
                 module=self._module,
                 port=self._port,
                 indices=[self._serdes_xindex],
-                pre2=pre2,
-                pre=pre,
-                main=main,
-                post=post,
-                pre3_post2=pre3_post2,
-                post3=post3,
-                mode=4))
+                tap_values=tap_values))
 
 
 @register_command

xoa_driver/internals/commands/pr_commands.py

@@ -284,21 +284,21 @@ class PR_TPLDERRORS:
     class GetDataAttr(ResponseBodyStruct):
         dummy: int = field(XmpLong())
         """long integer, not in use."""
-        non_incre_seq_event_count: int = field(XmpLong())
-        """long integer, number of non-incrementing-sequence-number events."""
-        swapped_seq_misorder_event_count: int = field(XmpLong())
-        """long integer, number of swapped-sequence-number misorder events."""
-        non_incre_payload_packet_count: int = field(XmpLong())
-        """long integer, number of packets with non-incrementing payload content."""
+        packet_loss_by_seq: int = field(XmpLong())
+        """long integer, Number of packet loss calculated by detecting gaps in received sequence numbers from test payload, where each missing number indicates a lost packet."""
+        misorder_by_seq: int = field(XmpLong())
+        """long integer, Number of misordered packets calculated by detecting packets that arrive with a sequence number lower than the highest seen so far, indicating out-of-order delivery."""
+        payload_err_packets: int = field(XmpLong())
+        """long integer, Number of packets with payload integrity errors."""
 
     def get(self) -> Token[GetDataAttr]:
         """Get statistics concerning errors in the packets with a particular test payload id received on a port.
 
         :return:
             dummy value not in use,
-            number of non-incrementing-sequence-number events,
-            number of swapped-sequence-number misorder events,
-            number of packets with non-incrementing payload content
+            Number of packet loss by sequence number,
+            Number of misordered packets by sequence number,
+            Number of packets with payload integrity errors.
 
         :rtype: PR_TPLDERRORS.GetDataAttr
         """
@@ -532,12 +532,13 @@ class PR_TOTALEXT:
         packet_count_since_cleared: int = field(XmpLong())
         """long integer, number of packets received since statistics were cleared."""
         fcs_error_count: int = field(XmpLong())
-
+        """long integer, number of Rx packets with a bad FCS."""
         oversize_count: int = field(XmpLong())
-
+        """long integer, number of oversize packets (>1518 bytes) received since last clear (-1 if this counter is not supported by the tester)."""
         undersize_count: int = field(XmpLong())
-
+        """long integer, number of undersize packets (<64 bytes) received since last clear (-1 if this counter is not supported by the tester)."""
         jabber_count: int = field(XmpLong())
+        """long integer, number of jabber packets (oversized with a bad FCS) received since last clear (-1 if this counter is not supported by the tester)."""
 
     def get(self) -> Token[GetDataAttr]:
         """Get statistics concerning all the packets received on a port.
@@ -548,10 +549,10 @@ class PR_TOTALEXT:
             number of packets received in the last second,
             number of bytes received since statistics were cleared,
             number of packets received since statistics were cleared,
-            number of packets received with fcs error frames,
-            number of oversize packets received since last clear (-1 if this counter is not supported by the tester),
-            number of undersize packets received since last clear (-1 if this counter is not supported by the tester),
-            number of jabber packets received since last clear (-1 if this counter is not supported by the tester).
+            number of packets received with a bad FCS,
+            number of oversize packets (>1518 bytes) received since last clear (-1 if this counter is not supported by the tester),
+            number of undersize packets (<64 bytes) received since last clear (-1 if this counter is not supported by the tester),
+            number of jabber packets (oversized with a bad FCS) received since last clear (-1 if this counter is not supported by the tester).
 
         :rtype: PR_TOTALEXT.GetDataAttr
         """

xoa_driver/internals/commands/pt_commands.py

@@ -166,8 +166,28 @@ class PT_EXTRA:
     _port: int
 
     class GetDataAttr(ResponseBodyStruct):
-        tx_arp_req_count: typing.List[int] = field(XmpSequence(types_chunk=[XmpLong()]))
+        tx_arp_request_count: int = field(XmpLong())
         """long integer, number of ARP requests transmitted"""
+        tx_arp_reply_count: int = field(XmpLong())
+        """long integer, number of ARP responses transmitted"""
+        tx_ping_request_count: int = field(XmpLong())
+        """long integer, number of PING requests transmitted"""
+        tx_ping_reply_count: int = field(XmpLong())
+        """long integer, number of PING responses transmitted"""
+        tx_fcs_inj_count: int = field(XmpLong())
+        """long integer, number of FCS errors injected"""
+        tx_seq_inj_count: int = field(XmpLong())
+        """long integer, number of sequence mismatch errors injected"""
+        tx_mis_inj_count: int = field(XmpLong())
+        """long integer, number of packet misordering errors injected"""
+        tx_pld_inj_count: int = field(XmpLong())
+        """long integer, number of payload errors injected"""
+        tx_tpld_inj_count: int = field(XmpLong())
+        """long integer, number of payload integrity errors injected"""
+        tx_mac_train_count: int = field(XmpLong())
+        """long integer, number of MAC learning (training) packets transmitted"""
+        tx_igmp_join_count: int = field(XmpLong())
+        """long integer, number of IGMP JOIN packets transmitted"""
 
     def get(self) -> Token[GetDataAttr]:
         """Get additional statistics for packets transmitted on a port.