tdl-xoa-driver 1.5.0b1__py3-none-any.whl → 1.5.1__py3-none-any.whl

{tdl_xoa_driver-1.5.0b1.dist-info → tdl_xoa_driver-1.5.1.dist-info}/METADATA

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: tdl-xoa-driver
-Version: 1.5.0b1
-Summary: XOA Driver is a Python library providing user-friendly communication interfaces to Teledyne LeCroy Xena Ethernet traffic generation test equipment. It provides a rich collection of APIs that can be used to either write test scripts or develop applications.
+Version: 1.5.1
+Summary: TDL XOA Python API is a Python library providing user-friendly communication interfaces to Teledyne LeCroy Xena Ethernet traffic generation test equipment. It provides a rich collection of APIs that can be used to either write test scripts or develop applications.
 Home-page: https://github.com/xenanetworks/tdl-xoa-driver
 Author: Leonard Yu, Zoltan Hanisch
 Author-email: Leonard.Yu@teledyne.com, Zoltan.Hanisch@teledyne.com
 Maintainer: Teledyne LeCroy Xena
 Maintainer-email: xena-sales@teledyne.com
 License: Apache 2.0
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: License :: OSI Approved :: Apache Software License
@@ -33,15 +33,15 @@ Dynamic: requires-python
 Dynamic: summary
 
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/tdl-xoa-driver) [![PyPI](https://img.shields.io/pypi/v/tdl-xoa-driver)](https://pypi.python.org/pypi/tdl-xoa-driver) [![Documentation Status](https://readthedocs.com/projects/xena-networks-tdl-xoa-driver/badge/?version=latest)](https://docs.xenanetworks.com/projects/tdl-xoa-driver/en/latest/?badge=latest)
-# XOA Driver
-XOA Driver is a standalone Python library that provides a user-friendly and powerful interface for automating network testing tasks using Xena Networks test equipment. Xena test equipment is a high-performance network test device designed for testing and measuring the performance of network equipment and applications.
+# TDL XOA Python API
+TDL XOA Python API is a standalone Python library that provides a user-friendly and powerful interface for automating network testing tasks using Xena Networks test equipment. Xena test equipment is a high-performance network test device designed for testing and measuring the performance of network equipment and applications.
 
 ## Introduction
-The XOA Driver is designed to be easy to use and integrate with other automation tools and frameworks. It provides a comprehensive set of methods and classes for interacting with Xena test equipment, including the ability to create and run complex test scenarios, generate and analyze traffic at line rate, and perform detailed analysis of network performance and behavior.
+The TDL XOA Python API is designed to be easy to use and integrate with other automation tools and frameworks. It provides a comprehensive set of methods and classes for interacting with Xena test equipment, including the ability to create and run complex test scenarios, generate and analyze traffic at line rate, and perform detailed analysis of network performance and behavior.
 
-The XOA Driver simplifies the process of automating network testing tasks using Xena test equipment. It provides a simple, yet powerful, interface for interacting with Xena test equipment using the Python programming language. With the XOA Driver, network engineers and testing professionals can easily create and execute test scenarios, generate and analyze traffic, and perform detailed analysis of network performance and behavior, all while leveraging the power and flexibility of the Python programming language.
+The TDL XOA Python API simplifies the process of automating network testing tasks using Xena test equipment. It provides a simple, yet powerful, interface for interacting with Xena test equipment using the Python programming language. With the TDL XOA Python API, network engineers and testing professionals can easily create and execute test scenarios, generate and analyze traffic, and perform detailed analysis of network performance and behavior, all while leveraging the power and flexibility of the Python programming language.
 
-Overall, the XOA Driver is a valuable tool for anyone looking to automate their network testing tasks using Xena test equipment. With its simple, yet powerful, interface and support for the Python programming language, the XOA Driver provides a flexible and extensible framework for automating network testing tasks and improving the quality of network infrastructure.
+Overall, the TDL XOA Python API is a valuable tool for anyone looking to automate their network testing tasks using Xena test equipment. With its simple, yet powerful, interface and support for the Python programming language, the TDL XOA Python API provides a flexible and extensible framework for automating network testing tasks and improving the quality of network infrastructure.
 
 ## Documentation
 The user documentation is hosted:

{tdl_xoa_driver-1.5.0b1.dist-info → tdl_xoa_driver-1.5.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
-tdl_xoa_driver-1.5.0b1.dist-info/licenses/LICENSE,sha256=Oc3Sih78tKR5tfTaIGcU3qytyX6JAzzAUlwW-qQaRaQ,11351
-xoa_driver/__init__.py,sha256=toYGpyit6mdS5499zhu0n3s6XQfzEKLMaKylpr_SP0Q,50
+tdl_xoa_driver-1.5.1.dist-info/licenses/LICENSE,sha256=Oc3Sih78tKR5tfTaIGcU3qytyX6JAzzAUlwW-qQaRaQ,11351
+xoa_driver/__init__.py,sha256=MoOXtGN9R7FyYbx-Vk03Fpdi6RNSyOSebZNGDSn2Xls,48
 xoa_driver/enums.py,sha256=SgwfIdPYol1AOZ-vl0ZtV3pRc3qXjm6QMq8ryOzjmuY,8559
 xoa_driver/exceptions.py,sha256=baNpophPmeNujMTSfL9TsYHa3Gju2-ozNOg78n8tqN8,1957
 xoa_driver/hlfuncs.py,sha256=tfyhbYX86XWpc4yFoBrj1OYqVJJfDnoxC6tHLlWTHkQ,311
@@ -16,12 +16,12 @@ xoa_driver/functions/exceptions.py,sha256=JlQSHNmiSS_mOQygqituLQF5fFVg38LG4Ktz7q
 xoa_driver/functions/headers.py,sha256=Rf_em8LqCZOz0oxiqvtAFwx71_CtD9_I0p-vEZWtc6E,33886
 xoa_driver/functions/mgmt.py,sha256=njuTrUDgtXwNk0OllFjCObVJXwQ4l4-a2RA7KAORpZU,16513
 xoa_driver/functions/tools.py,sha256=d4p-v49qwXCQW1NFKRhLmT7Lje2H8EGaRy2inDmLJ18,9786
-xoa_driver/functions/cli/__init__.py,sha256=OAl_kI2q7qf9aDsm2ib5_UIUSHpXLcLNFMMF9dlhwNc,468
-xoa_driver/functions/cli/_cli_manager.py,sha256=B_ILKXL3VhoTGWzB4UrB1UV7LQKc2C45pm9m4BJSaEA,22162
+xoa_driver/functions/cli/__init__.py,sha256=1qCG8oiucQ51v8tS6mAvu9MpBDQ4dqDhzx-EvdhDTQQ,458
+xoa_driver/functions/cli/_cli_manager.py,sha256=MKU2wS0Gxd514zvyWsm4qiYg-WLPA6vrHZy2QFcqpsU,22166
 xoa_driver/functions/cli/_config_block.py,sha256=KaNiAq4ht6Hfoo7iE2h03SAXhE3WX5efyHJcE74dYto,12245
 xoa_driver/functions/cli/_socket_driver.py,sha256=rVmkSQZr4Ygu8NNkOSuW9_5dqaSc0kpF1SUaV2jPwJs,3334
-xoa_driver/functions/cli/port_config.py,sha256=4YX7tIWXXtgKWM6-9Nt_bXhY-SfWv0hqA4U26SvvH4I,4170
-xoa_driver/functions/cli/test_case_config.py,sha256=_dLPENNihGO40PPpg99LJxPe8TSkXTRFavN07bMdfPY,8016
+xoa_driver/functions/cli/port_config.py,sha256=VYsrRyuB7gctUlNLb2gqYXz_slj41lkdAGsj8AePqCU,4534
+xoa_driver/functions/cli/testbed_config.py,sha256=EU2xZHFO4ugWK-cEg9IA2foNON2-n2RjTej0cN68M-U,8229
 xoa_driver/functions/cmis/__init__.py,sha256=AWHrzTQYDJFmC_7vkZfin6AhehyQRojxbWLUNhCIlzc,113
 xoa_driver/functions/cmis/_constants.py,sha256=VqjqpeByPEHMnMNdEeQe8hwUe6-QwtOMDwusiay638g,645
 xoa_driver/functions/cmis/_replies.py,sha256=kw-7Ua_Ddu5_9fjVwQfEI-AlyPy6-c7uS7HyPKgNHHQ,22975
@@ -38,7 +38,7 @@ xoa_driver/internals/commands/m_commands.py,sha256=gslylrFybNN4juTqNkCENiGWvosWz
 xoa_driver/internals/commands/p4_commands.py,sha256=3nj6suKf0PCC7jMSGidzeAmm4VTpFd5qz2FukuF5R40,78768
 xoa_driver/internals/commands/p4e_commands.py,sha256=2hIa6S5aHY_Bht1QQ3ql3cFTLoWwwcGzvslAXeXc6rg,5056
 xoa_driver/internals/commands/p4g_commands.py,sha256=noIrvLYsjrc_t9hQ0msOCaOA0NsVNdTIySIjHoJEnOM,292438
-xoa_driver/internals/commands/p_commands.py,sha256=4UKJXG1T9dyN5QUH8AUorCRQT1orddf4mT0a2gfkFOs,228549
+xoa_driver/internals/commands/p_commands.py,sha256=GlZ1P2zAlKZPlePs-apRyYEjsKreKbdHg4NuCsl02Uw,230083
 xoa_driver/internals/commands/pc_commands.py,sha256=uJe-wTla8vVDFChfSqpDNbpxCwx9OJ7WET2oM5KNHOs,11060
 xoa_driver/internals/commands/pd_commands.py,sha256=s0Ts7RN6WASyUGuuGmlxEPxDKSsnM50SXRbIFhTtsiQ,12492
 xoa_driver/internals/commands/pe_commands.py,sha256=z5YgV85RMw6CFYQF5Z8qKyCujiGk1psV-KYEdZeIBkU,38690
@@ -46,10 +46,10 @@ xoa_driver/internals/commands/pec_commands.py,sha256=bu2uSpMObsGob1QM4YzyhVAW6aN
 xoa_driver/internals/commands/ped_commands.py,sha256=J_QQxgrun71UWFpOQTFBxZe5tK-hOPxtCWiAGFKSc8Y,39736
 xoa_driver/internals/commands/pef_commands.py,sha256=q-JLQ2-JOHwfu-Ku28cc89mwJtKP_rJ9-QtFvOOxNVk,82219
 xoa_driver/internals/commands/pf_commands.py,sha256=5PVBA8N6G-1O6PN1l1XmmKKYS8DkGRz2NV6z6NuppKU,14540
-xoa_driver/internals/commands/pl1_commands.py,sha256=mM0kNH8Te2YXD-OfDqkJv1Q5EwsHbczBSM0iTZAQWYQ,66370
+xoa_driver/internals/commands/pl1_commands.py,sha256=oJVLGGoSDyL3X8Llmhm36Ajp38gsJgQLcI69RXZEHnE,69312
 xoa_driver/internals/commands/pl_commands.py,sha256=znhmeTgPlqURsJ2dxIvQnOioE-qU2650fLtHaK0ZiMs,6382
 xoa_driver/internals/commands/pm_commands.py,sha256=tlt3yoEpCnjRmJ2EEq-BCOeBH4oppXvl5mea172Z_KA,9514
-xoa_driver/internals/commands/pp_commands.py,sha256=dKi8oqE0iKOVdtiTjqrZq772NfkpcafR8xMR6HdE69E,82762
+xoa_driver/internals/commands/pp_commands.py,sha256=VK03-T3695ehn9l_tBNmKYf4L7qo-mxUAcpxLalq_Vk,82448
 xoa_driver/internals/commands/pr_commands.py,sha256=CeDP8ZJPGiwFUKkgFfYN84loNwWDxQdHV4Fi2JVuYZI,31871
 xoa_driver/internals/commands/ps_commands.py,sha256=o5x24Z7kz-3jXRsTxmehkmG_0pbeYLldFbtPgu6fEZQ,96440
 xoa_driver/internals/commands/pt_commands.py,sha256=bBWPSppymycMH3CDZLQJoDXR2YdRsGJpVB3MVRNa81Q,15187
@@ -147,10 +147,11 @@ xoa_driver/internals/hli/modules/modules_l23/module_l23_base.py,sha256=TIB77QUNf
 xoa_driver/internals/hli/ports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xoa_driver/internals/hli/ports/base_port.py,sha256=8p25Wh2lTd9CEFueuhm-y8yvNMIW8yoz6oUxVbWlFC8,3646
 xoa_driver/internals/hli/ports/port_l23/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xoa_driver/internals/hli/ports/port_l23/edun_l1.py,sha256=bXOzhk_TByWdmaTQf4ZlpEdvJBKNtxMsSJnEd2V4dBs,5853
 xoa_driver/internals/hli/ports/port_l23/family_combi.py,sha256=0FCeQ0B2Jjth7jqvJexSI6ODCZk6Rm48_Vr_edZBRyI,1001
 xoa_driver/internals/hli/ports/port_l23/family_d.py,sha256=o9QzNcBORpAbsFSl_MN83J4Tjhmk7w77bAN2FlRyyWQ,1166
 xoa_driver/internals/hli/ports/port_l23/family_e.py,sha256=s7aL5b9d9E8Zsm63oIqA6ZUZ74PPug8GPWpsHQsJRCs,2678
-xoa_driver/internals/hli/ports/port_l23/family_edun.py,sha256=YWeT_RUEEZaQRcu3HybTo34H1A9bApopHZITdud0cms,2260
+xoa_driver/internals/hli/ports/port_l23/family_edun.py,sha256=Rm95n8z6qLNTE41nbhr_VaK8tJ4yy8boKyIWgQwOZbs,2275
 xoa_driver/internals/hli/ports/port_l23/family_f.py,sha256=vx0rN-vQP7v8m5Pcc6RvlisNui0IxMxKvab54Iwn2_4,4007
 xoa_driver/internals/hli/ports/port_l23/family_g.py,sha256=OeDpsOr-65V_FWuhifeXH3gaJpKbyftdtWgU8X-_ous,2011
 xoa_driver/internals/hli/ports/port_l23/family_h.py,sha256=MeUehj0unvHX9W3glfVORKdqX8kbu-hmZvMtwJbE-go,1840
@@ -158,7 +159,7 @@ xoa_driver/internals/hli/ports/port_l23/family_i.py,sha256=ZHXXiO0LOUbRCSXcYize1
 xoa_driver/internals/hli/ports/port_l23/family_j.py,sha256=SZ2RYsI63Z6xatcfIcyLobrpuuofdEFty3JU51s2tcY,1858
 xoa_driver/internals/hli/ports/port_l23/family_k.py,sha256=X8l9kZe58dizhzNbC-JY3z2m-_YwsGdE_tf_73NiZw0,1952
 xoa_driver/internals/hli/ports/port_l23/family_l.py,sha256=Ao3-XNKpBi-4s49guS5Yc8Hk0DWX0yJ40YMnL0KjzdU,2148
-xoa_driver/internals/hli/ports/port_l23/family_l1.py,sha256=WWaEe7qmdE3xY9ExO6HLHjymCGMrNeRLCpcetcyCnmI,3851
+xoa_driver/internals/hli/ports/port_l23/family_l1.py,sha256=DifAvVGI48gx4ps1syQJ1B1FnxYz9gkLhQVqcCv1pxc,3867
 xoa_driver/internals/hli/ports/port_l23/family_m.py,sha256=rvYpgYvN9Mrb_abxW-J1Zwn-36nCh_oBrNF0IV2qcIE,779
 xoa_driver/internals/hli/ports/port_l23/fault_jkl.py,sha256=vsbpTsBGhQJHlb6cdhaKIIosif4Vh5mn5luYO_tOPtk,641
 xoa_driver/internals/hli/ports/port_l23/freya_l1.py,sha256=wdNZDLHrSd3SxFVR3-C3ZPcE4SzjfcdsoLeKjV6_UuI,28777
@@ -224,7 +225,7 @@ xoa_driver/internals/utils/managers/abc.py,sha256=M3XgI2FVQLUXixS5SKnZTm0MweHY6D
 xoa_driver/internals/utils/managers/exceptions.py,sha256=fqLSin-OQCIKuhpzvK6RZThF3FJ8FsHers4EmqM9gSs,628
 xoa_driver/internals/utils/managers/modules_manager.py,sha256=sCEhqUu7Waot16rucJ5nI9FyHuFEeU_sBx1JjZdhDJg,3236
 xoa_driver/internals/utils/managers/ports_manager.py,sha256=FRizJ4-V0iE66cSuswW01-6QvXhCuGxHGvmtaDVOeFg,3484
-tdl_xoa_driver-1.5.0b1.dist-info/METADATA,sha256=QJGr1OksZNy3I8SyINx0bWSjpPOFvN2UL2Mqwraga0c,4101
-tdl_xoa_driver-1.5.0b1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tdl_xoa_driver-1.5.0b1.dist-info/top_level.txt,sha256=sBbN3hwpa4s2VxsUBoWJ5jIqqDr50vgcEb-V8kL7pvE,11
-tdl_xoa_driver-1.5.0b1.dist-info/RECORD,,
+tdl_xoa_driver-1.5.1.dist-info/METADATA,sha256=YTQ9KKaQNsNZ7N8dr5OOY_4tmPzxbsM9J9ln3ve6Huo,4176
+tdl_xoa_driver-1.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tdl_xoa_driver-1.5.1.dist-info/top_level.txt,sha256=sBbN3hwpa4s2VxsUBoWJ5jIqqDr50vgcEb-V8kL7pvE,11
+tdl_xoa_driver-1.5.1.dist-info/RECORD,,

xoa_driver/__init__.py

@@ -1,2 +1,2 @@
-__version__ = "1.5.0b1"
+__version__ = "1.5.1"
 __short_version__ = "1.5"

xoa_driver/functions/cli/__init__.py

@@ -6,16 +6,16 @@ from .port_config import (
     load_port_config,
     port_config_from_file,
 )
-from .test_case_config import (
-    save_test_case_config,
-    load_test_case_config,
+from .testbed_config import (
+    save_testbed_config,
+    load_testbed_config,
     module_config_from_file,
 )
 __all__ = (
     "save_port_config",
     "load_port_config",
     "port_config_from_file",
-    "save_test_case_config",
-    "load_test_case_config",
+    "save_testbed_config",
+    "load_testbed_config",
     "module_config_from_file",
 )

xoa_driver/functions/cli/_cli_manager.py

@@ -150,12 +150,12 @@ class XOACLIManager:
             # Check for C_LOGON or password in string, as a safeguard
             if re.search(r'C_LOGON\s*".*"', msg) or re.search(r'password\s*=\s*".*"', msg, flags=re.IGNORECASE) or re.search(r'--password=\S+', msg, flags=re.IGNORECASE):
                 logging.info(f"{time.time()} [Sensitive command redacted]")
-                print(f"{time.time()} [Sensitive command redacted]")
+                # print(f"{time.time()} [Sensitive command redacted]")
                 return
             # Redact as an additional precaution
             safe_msg = _redact_sensitive(msg)
             logging.info(f"{time.time()} {safe_msg}")
-            print(f"{time.time()} {safe_msg}")
+            # print(f"{time.time()} {safe_msg}")
     def log_command(self, cmd:str) -> None:
         """Place the command in the log cmd list for later logging
 

xoa_driver/functions/cli/port_config.py

@@ -1,10 +1,11 @@
 import asyncio
 from xoa_driver import testers, ports
+from typing import List, Tuple
 from ._cli_manager import XOACLIManager
 from ._config_block import *
 
 async def save_port_config(tester: testers.L23Tester, port: ports.GenericL23Port, path: str, debug=False, halt_on_error=False) -> str:
-    """Save configuration from the test port to the specified filepath
+    """Save port config to the specified filepath
 
     :param tester: Chassis object
     :type tester: testers.L23Tester
@@ -48,12 +49,12 @@ async def save_port_config(tester: testers.L23Tester, port: ports.GenericL23Port
 
     # Save configuration to file
     result = port_config_block.config_block_str
-    with open(path, 'w+', newline='') as xpcfile:
+    with open(path, 'w+') as xpcfile:
         xpcfile.write(result)
     return result
 
-async def load_port_config(tester: testers.L23Tester, port: ports.GenericL23Port, path: str, debug=False, halt_on_error=False) -> None:
-    """Load configuration to the test port from the specified filepath
+async def load_port_config(tester: testers.L23Tester, port: ports.GenericL23Port, path: str, debug=False, halt_on_error=False) -> List[Tuple[str, str]]:
+    """Load port config from the specified filepath
 
     :param tester: Chassis object
     :type tester: testers.L23Tester
@@ -61,6 +62,8 @@ async def load_port_config(tester: testers.L23Tester, port: ports.GenericL23Port
     :type port: ports.GenericL23Port
     :param load_path: File path to load the port configuration from
     :type load_path: str
+    :return: List of tuples containing response and the corresponding command sent
+    :rtype: List[Tuple[str, str]]
     """
     
     tester_ip = tester.info.host
@@ -77,8 +80,10 @@ async def load_port_config(tester: testers.L23Tester, port: ports.GenericL23Port
     # Reserve the port before applying configuration
     xm.reserve_port(port_index)
 
+    result: List[Tuple[str, str]] = []
+
     # Read configuration from file
-    with open(path, 'r', newline='') as xpcfile:
+    with open(path, 'r', encoding='utf-8') as xpcfile:
         config_data = xpcfile.read()
 
     # Deserialize config block and send CLI commands
@@ -87,12 +92,14 @@ async def load_port_config(tester: testers.L23Tester, port: ports.GenericL23Port
     cli_cmds = config_block.commands
     for cmd in cli_cmds:
         if cmd.strip():  # Ensure the command is not empty
-            xm.send(cmd=f"{port_index} {cmd}", sync_on=False)
+            resp = xm.send(cmd=f"{port_index} {cmd}", sync_on=False)
+            result.append((resp, f"{port_index} {cmd}"))
 
     # Free the port after applying configuration
     xm.free_port(port_index)
+    return result
 
-async def port_config_from_file(tester: testers.L23Tester, port: ports.GenericL23Port, path: str, debug=False, halt_on_error=False) -> None:
+async def port_config_from_file(tester: testers.L23Tester, port: ports.GenericL23Port, path: str, debug=False, halt_on_error=False) -> List[Tuple[str, str]]:
     """Load port configuration from the specifiied filepath. This function is a wrapper around load_port_config to provide backward compatibility.
 
     :param tester: Chassis object
@@ -101,7 +108,9 @@ async def port_config_from_file(tester: testers.L23Tester, port: ports.GenericL2
     :type port: ports.GenericL23Port
     :param load_path: File path to load the port configuration from
     :type load_path: str
+    :return: List of tuples containing response and command sent
+    :rtype: List[Tuple[str, str]]
     """
-    await load_port_config(tester, port, path, debug=debug, halt_on_error=halt_on_error)
+    return await load_port_config(tester, port, path, debug=debug, halt_on_error=halt_on_error)
 
 

xoa_driver/functions/cli/{test_case_config.py → testbed_config.py}

@@ -1,12 +1,12 @@
 import asyncio
 from xoa_driver import testers, modules, ports
 from ._cli_manager import XOACLIManager
-from typing import List
+from typing import List, Tuple
 from ..mgmt import *
 from ._config_block import *
 
-async def save_test_case_config(tester: testers.L23Tester, ports: List[ports.GenericL23Port], path: str, testbed_name: str = "<testbed>", with_module_config: bool = True, debug=False, halt_on_error=False) -> str:
-    """Save module configuration to the specifiied filepath
+async def save_testbed_config(tester: testers.L23Tester, ports: List[ports.GenericL23Port], path: str, testbed_name: str = "<testbed>", with_module_config: bool = True, debug=False, halt_on_error=False) -> str:
+    """Save testbed configuration to the specifiied filepath
 
     :param tester: Chassis object
     :type tester: testers.L23Tester
@@ -90,13 +90,13 @@ async def save_test_case_config(tester: testers.L23Tester, ports: List[ports.Gen
         port_config_block.commands = raw_resp[0]
         result += "\n" + ";\n" + port_config_block.config_block_str
         
-    with open(path, 'w+', newline='') as xtcfile:
+    with open(path, 'w+') as xtcfile:
         xtcfile.write(result)
     
     return result
 
-async def load_test_case_config(tester: testers.L23Tester, path: str, mode: str = "default", delay_after_module_config: int = 5, debug=False, halt_on_error=False) -> None:
-    """Load module configuration from the specifiied filepath
+async def load_testbed_config(tester: testers.L23Tester, path: str, mode: str = "default", delay_after_module_config: int = 5, debug=False, halt_on_error=False) -> List[Tuple[str, str]]:
+    """Load testbed configuration from the specifiied filepath
 
     :param tester: Chassis object
     :type tester: testers.L23Tester
@@ -106,6 +106,8 @@ async def load_test_case_config(tester: testers.L23Tester, path: str, mode: str
     :type mode: str
     :param delay_after_module_config: Delay in seconds after configuring each module to ensure proper configuration
     :type delay_after_module_config: int
+    :return: List of tuples containing response and the corresponding command sent
+    :rtype: List[Tuple[str, str]]
     """
 
     tester_ip = tester.info.host
@@ -118,50 +120,55 @@ async def load_test_case_config(tester: testers.L23Tester, path: str, mode: str
     # Log on and set username
     xm.logon_set_owner(tester_password)
 
+    result: List[Tuple[str, str]] = []
+
     # Read configuration from file
-    with open(path, 'r', newline='') as xpcfile:
+    with open(path, 'r') as xpcfile:
         config_data = xpcfile.read()
 
-        # Parse the config data to configure modules and ports block by block
-        config_datas = config_data.split(f";\n")
-        for block in config_datas:
-            if config_block_type(config_block_str=block) == ConfigMetadataType.MODULE and mode in ["default", "module"]:
-                module_block = ConfigBlock()
-                module_block.config_block_str = block
-                module_index = module_block.module_id
-
-                # Free the module before applying configuration
-                module = tester.modules.obtain(int(module_index))
-                await release_module(module=module, should_release_ports=True)
-                # Reserve the module before applying configuration
-                xm.reserve_module(module_index)
-
-                # Send each command to the tester
-                for cmd in module_block.commands:
-                    if cmd.strip():  # Ensure the command is not empty
-                        print(f"Applying command: {module_index} {cmd}")
-                        xm.send(cmd=f"{module_index} {cmd}", sync_on=False)
-                # Free the module after applying configuration
-                xm.free_module(module_index)
-                await asyncio.sleep(delay_after_module_config)  # Small delay to ensure proper module configuration
-
-            elif config_block_type(config_block_str=block) == ConfigMetadataType.PORT and mode in ["default", "port"]:
-                port_block = ConfigBlock()
-                port_block.config_block_str = block
-                port_index = port_block.port_id
-
-                # Reserve the port before applying configuration
-                xm.reserve_port(port_index)
-
-                # Send each command to the tester
-                for cmd in port_block.commands:
-                    if cmd.strip():  # Ensure the command is not empty
-                        print(f"Applying command: {port_index} {cmd}")
-                        xm.send(cmd=f"{port_index} {cmd}", sync_on=False)
-                # Free the port after applying configuration
-                xm.free_port(port_index)
-
-async def module_config_from_file(tester: testers.L23Tester, path: str, debug=False, halt_on_error=False) -> None:
+    # Parse the config data to configure modules and ports block by block
+    config_datas = config_data.split(f";\n")
+    for block in config_datas:
+        if config_block_type(config_block_str=block) == ConfigMetadataType.MODULE and mode in ["default", "module"]:
+            module_block = ConfigBlock()
+            module_block.config_block_str = block
+            module_index = module_block.module_id
+
+            # Free the module before applying configuration
+            module = tester.modules.obtain(int(module_index))
+            await release_module(module=module, should_release_ports=True)
+            # Reserve the module before applying configuration
+            xm.reserve_module(module_index)
+
+            # Send each command to the tester
+            for cmd in module_block.commands:
+                if cmd.strip():  # Ensure the command is not empty
+                    # print(f"Applying command: {module_index} {cmd}")
+                    resp = xm.send(cmd=f"{module_index} {cmd}", sync_on=False)
+                    result.append((resp, f"{module_index} {cmd}"))
+            # Free the module after applying configuration
+            xm.free_module(module_index)
+            await asyncio.sleep(delay_after_module_config)  # Small delay to ensure proper module configuration
+
+        elif config_block_type(config_block_str=block) == ConfigMetadataType.PORT and mode in ["default", "port"]:
+            port_block = ConfigBlock()
+            port_block.config_block_str = block
+            port_index = port_block.port_id
+
+            # Reserve the port before applying configuration
+            xm.reserve_port(port_index)
+
+            # Send each command to the tester
+            for cmd in port_block.commands:
+                if cmd.strip():  # Ensure the command is not empty
+                    # print(f"Applying command: {port_index} {cmd}")
+                    resp = xm.send(cmd=f"{port_index} {cmd}", sync_on=False)
+                    result.append((resp, f"{port_index} {cmd}"))
+            # Free the port after applying configuration
+            xm.free_port(port_index)
+    return result
+
+async def module_config_from_file(tester: testers.L23Tester, path: str, debug=False, halt_on_error=False) -> List[Tuple[str, str]]:
     """Load module configuration from the specifiied filepath. This function is a wrapper around load_module_config to provide backward compatibility.
 
     :param tester: Chassis object
@@ -169,4 +176,4 @@ async def module_config_from_file(tester: testers.L23Tester, path: str, debug=Fa
     :param path: File path to load the module configuration from
     :type path: str
     """
-    await load_test_case_config(tester, path, mode="module", debug=debug, halt_on_error=halt_on_error)
+    return await load_testbed_config(tester, path, mode="module", debug=debug, halt_on_error=halt_on_error)

xoa_driver/internals/commands/p_commands.py

@@ -601,7 +601,44 @@ class P_CAPABILITIES:
         * Bit 0: Normal modifier (16/24-bit) supports little-endian
         * Bit 1: Extended modifier (32-bit) supports little-endian
         """
-        
+        capture_bitmask: int = field(XmpInt(), min_version=470)
+        """integer, bitmask indicating capture capabilities.
+
+        If all bits are 0: CAPTURE_NOT_SUPPORTED
+
+        Bits [0:11] are for Start triggers:
+
+        * Bit 0: CAPTURE_START_ON
+        * Bit 1: CAPTURE_START_FCSERROR
+        * Bit 2: CAPTURE_START_FILTER
+        * Bit 3: CAPTURE_START_PLDERROR
+        * Bit 4-11: Reserved
+
+        Bits [12:23] are for Stop triggers:
+
+        * Bit 12: CAPTURE_STOP_FULL
+        * Bit 13: CAPTURE_STOP_FCSERROR
+        * Bit 14: CAPTURE_STOP_FILTER
+        * Bit 15: CAPTURE_STOP_PLDERROR
+        * Bit 16: CAPTURE_STOP_USERSTOP
+        * Bit 17-23: Reserved
+
+        Bits [24:31] are for Keep modes:
+
+        * Bit 24: CAPTURE_KEEP_ALL
+        * Bit 25: CAPTURE_KEEP_FCSERR
+        * Bit 26: CAPTURE_KEEP_NOTPLD
+        * Bit 27: CAPTURE_KEEP_TPLD
+        * Bit 28: CAPTURE_KEEP_FILTER
+        * Bit 29: CAPTURE_KEEP_PLDERR
+        * Bit 30-31: Reserved
+        """
+        num_txeq_pre: int = field(XmpInt(), min_version=470)
+        """The number of postcursors = num_txeq - num_txeq_pre - 1."""
+        txeq_max_seq: typing.List[int] = field(XmpSequence(types_chunk=[XmpInt()], length=10), min_version=470)
+        """max value of individual TXEQ taps, SEQuential: <pre-n> <pre-(n-q)> ... <prr1> <main> <post1> <post2> ...."""
+        txeq_min_seq: typing.List[int] = field(XmpSequence(types_chunk=[XmpInt()], length=10), min_version=470)
+        """min-value of individual TXEQ taps, SEQuential: <pre-n> <pre-(n-q)> ... <prr1> <main> <post1> <post2> ...."""
 
 
     def get(self) -> Token[GetDataAttr]:
@@ -1512,7 +1549,6 @@ class P_XMITONE:
         A valid Frame Check Sum is written into the final four bytes.
 
         :param hex_data: raw bytes of the packet in hex to transmit
-        :rtype: typing.List[str]
         """
 
         return Token(self._connection, build_set_request(self, module=self._module, port=self._port, hex_data=hex_data))

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/hli/ports/port_l23/edun_l1.py

@@ -0,0 +1,181 @@
+from typing import (
+    TYPE_CHECKING,
+    Tuple,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    PP_PRECODING,
+    PP_GRAYCODING,
+    PL1_PHYTXEQ_LEVEL,
+    PL1_PHYTXEQ_COEFF,
+    PL1_PCS_VARIANT,
+    PL1_PHYTXEQ,
+    PL1_CWE_CYCLE,
+    PL1_CWE_ERR_SYM_INDICES,
+    PL1_CWE_BIT_ERR_MASK,
+    PL1_CWE_FEC_ENGINE,
+    PL1_CWE_FEC_STATS,
+    PL1_CWE_CONTROL,
+    PL1_CWE_FEC_STATS_CLEAR,
+    PP_PRBSTYPE,
+    PL1_PNSWAP_RX,
+    PL1_PNSWAP_TX,
+    PP_AUTONEG,
+    PP_AUTONEGSTATUS,
+    PP_LINKTRAIN,
+)
+from .pcs_pma_ghijkl import (
+    Prbs,
+)
+from xoa_driver import enums
+
+class EdunPMA:
+    """Edun PMA"""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, serdes_xindex: int) -> None:
+        self.precoding = PP_PRECODING(conn, module_id, port_id, serdes_xindex)
+        """GET/SET Pre-Coding Configurations.
+
+        :type: PP_PRECODING
+        """
+
+        self.graycoding = PP_GRAYCODING(conn, module_id, port_id, serdes_xindex)
+        """GET/SET Gray-Coding Configurations.
+
+        :type: PP_GRAYCODING
+        """
+
+        self.pn_swap_rx = PL1_PNSWAP_RX(conn, module_id, port_id, serdes_xindex)
+        """GET/SET PN-Swap RX Configurations. 
+
+        :type: PL1_PNSWAP_RX
+        """
+
+        self.pn_swap_tx = PL1_PNSWAP_TX(conn, module_id, port_id, serdes_xindex)
+        """GET/SET PN-Swap TX Configurations.
+        
+        :type: PL1_PNSWAP_TX
+        """
+
+class EdunTxTap:
+    """Edun Tx Tap"""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, serdes_xindex: int) -> None:
+        self.native = PL1_PHYTXEQ(conn, module_id, port_id, serdes_xindex)
+        """TX tap native value. (only for Edun)
+
+        :type: PL1_PHYTXEQ
+        """
+
+        self.level = PL1_PHYTXEQ_LEVEL(conn, module_id, port_id, serdes_xindex)
+        """TX tap mV/dB value. (only for Edun)
+
+        :type: PL1_PHYTXEQ_LEVEL
+        """
+
+        self.ieee = PL1_PHYTXEQ_COEFF(conn, module_id, port_id, serdes_xindex)
+        """TX tap IEEE coefficient value. (only for Edun)
+
+        :type: PL1_PHYTXEQ_COEFF
+        """
+
+# class EdunRxTap:
+#     """Edun Rx tap
+#     """
+    # def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, serdes_xindex: int) -> None:
+    #     self.status = P_EDUN_RX_STATUS(conn, module_id, port_id, serdes_xindex)
+    #     """Edun Rx tap status
+    #     """
+
+class EdunMedium:
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, serdes_xindex: int) -> None:
+        self.tx = EdunTxTap(conn, module_id, port_id, serdes_xindex)
+        """Edun Tx tap
+        """
+        # self.rx = EdunRxTap(conn, module_id, port_id, serdes_xindex)
+        # """Edun Rx tap
+        # """
+
+class SerDesEdun:
+    """L23 high-speed port SerDes configuration and status."""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, serdes_xindex: int) -> None:
+
+        self.prbs = Prbs(conn, module_id, port_id, serdes_xindex)
+        """PRBS
+        :type: Prbs
+        """
+        
+        self.pma = EdunPMA(conn, module_id, port_id, serdes_xindex)
+        """Edun PMA
+
+        :type: EdunPMA
+        """
+
+        self.medium = EdunMedium(conn, module_id, port_id, serdes_xindex)
+        """Edun medium
+
+        :type: EdunMedium
+        """
+
+class EdunAutoneg:
+    """Edun port-level autoneg. For per-serdes configuration and status, use serdes[x]
+    """
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.config = PP_AUTONEG(conn, module_id, port_id)
+        """Autoneg config and status
+        """
+        self.status = PP_AUTONEGSTATUS(conn, module_id, port_id)
+        """Autoneg status
+        """
+
+class EdunFecCodewordErrorInject:
+    """Edun FEC Codeword Error Injection
+    """
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.cycle = PL1_CWE_CYCLE(conn, module_id, port_id)
+        """FEC codeword error injection cycle.
+        """
+        self.err_symbols = PL1_CWE_ERR_SYM_INDICES(conn, module_id, port_id)
+        """The positions of the errored symbols in errored codewords.
+        """
+        self.bit_err_mask = PL1_CWE_BIT_ERR_MASK(conn, module_id, port_id)
+        """The bit error mask for the errored symbols.
+        """
+        self.engine = PL1_CWE_FEC_ENGINE(conn, module_id, port_id)
+        """The FEC engines to use.
+        """
+        self.statistics = PL1_CWE_FEC_STATS(conn, module_id, port_id)
+        """FEC error injection statistics
+        """
+        self.clear_stats = PL1_CWE_FEC_STATS_CLEAR(conn, module_id, port_id)
+        """Clear FEC codeword injection stats
+        """
+        self.control = PL1_CWE_CONTROL(conn, module_id, port_id)
+        """Control the FEC codeword error injection
+        """
+
+class Layer1:
+    def __init__(self, conn: "itf.IConnection", port) -> None:
+        self.serdes: Tuple[SerDesEdun, ...] = tuple(
+                SerDesEdun(conn, *port.kind, serdes_xindex=idx)
+                for idx in range(port.info.capabilities.serdes_count)
+                )
+        self.autoneg = EdunAutoneg(conn, *port.kind)
+        """Edun port-level autoneg. For per-serdes configuration and status, use serdes[x]
+        """
+        self.lt = PP_LINKTRAIN(conn, *port.kind)
+        """Edun Link Training on serdes level
+
+        :type: PP_LINKTRAIN
+        """
+        self.pcs_variant = PL1_PCS_VARIANT(conn, *port.kind)
+        """PCS variant configuration
+        """
+        self.fec_error_inject = EdunFecCodewordErrorInject(conn, *port.kind)
+        """FEC codeword error injection
+        """
+        self.prbs_config = PP_PRBSTYPE(conn, *port.kind)
+        """PRBS configuration, including PRBS polynomial, invert mode, and statistic collection mode (for RX).
+        """

xoa_driver/internals/hli/ports/port_l23/family_edun.py

@@ -17,7 +17,7 @@ from .pcs_pma_ghijkl import (
     SerDes,
 )
 from .pcs_pma_l import PcsPma as PcsPma3  
-from .freya_l1 import Layer1
+from .edun_l1 import Layer1
 
 class PcsPma(PcsPma1, PcsPma2, PcsPma3):
     """Edun PCS/PMA
@@ -41,11 +41,11 @@ class FamilyEdun(BasePortL23Genuine):
     :type: PcsPma
     """
     
-    serdes: Tuple[SerDes, ...]
-    """SerDes index
+    # serdes: Tuple[SerDes, ...]
+    # """SerDes index
 
-    :type: Tuple[SerDes, ...]
-    """
+    # :type: Tuple[SerDes, ...]
+    # """
 
     def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
         super().__init__(conn, module_id, port_id)
@@ -60,10 +60,10 @@ class FamilyEdun(BasePortL23Genuine):
     async def _setup(self) -> Self:
         await super()._setup()
         self.pcs_pma = PcsPma(self._conn, self)
-        self.serdes = tuple(
-            SerDes(self._conn, *self.kind, serdes_xindex=serdes_xindex)
-            for serdes_xindex in range(self.info.capabilities.serdes_count)
-        )
+        # self.serdes = tuple(
+        #     SerDes(self._conn, *self.kind, serdes_xindex=serdes_xindex)
+        #     for serdes_xindex in range(self.info.capabilities.serdes_count)
+        # )
         self.l1 = L1(self._conn, self)
         return self
 

xoa_driver/internals/hli/ports/port_l23/family_l1.py

@@ -41,11 +41,11 @@ class FamilyFreya(BasePortL23Genuine):
     :type: PcsPma
     """
     
-    serdes: Tuple[SerDes, ...]
-    """SerDes index
+    # serdes: Tuple[SerDes, ...]
+    # """SerDes index
 
-    :type: Tuple[SerDes, ...]
-    """
+    # :type: Tuple[SerDes, ...]
+    # """
 
     def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
         super().__init__(conn, module_id, port_id)
@@ -60,10 +60,10 @@ class FamilyFreya(BasePortL23Genuine):
     async def _setup(self) -> Self:
         await super()._setup()
         self.pcs_pma = PcsPma(self._conn, self)
-        self.serdes = tuple(
-            SerDes(self._conn, *self.kind, serdes_xindex=serdes_xindex)
-            for serdes_xindex in range(self.info.capabilities.serdes_count)
-        )
+        # self.serdes = tuple(
+        #     SerDes(self._conn, *self.kind, serdes_xindex=serdes_xindex)
+        #     for serdes_xindex in range(self.info.capabilities.serdes_count)
+        # )
         self.l1 = L1(self._conn, self)
         return self