tdl-xoa-driver 1.5.0__tar.gz → 1.5.0b1__tar.gz

{tdl_xoa_driver-1.5.0/tdl_xoa_driver.egg-info → tdl_xoa_driver-1.5.0b1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: tdl-xoa-driver
-Version: 1.5.0
-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.
+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.
 Home-page: https://github.com/xenanetworks/tdl-xoa-driver
 Author: Leonard Yu, Zoltan Hanisch
 Author-email: Leonard.Yu@teledyne.com, Zoltan.Hanisch@teledyne.com
@@ -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)
-# 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.
+# 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.
 
 ## Introduction
-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 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 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.
+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.
 
-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.
+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.
 
 ## Documentation
 The user documentation is hosted:

tdl_xoa_driver-1.5.0b1/README.md

@@ -0,0 +1,22 @@
+![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.
+
+## 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 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.
+
+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.
+
+## Documentation
+The user documentation is hosted:
+[XOA Driver Documentation](https://docs.xenanetworks.com/projects/tdl-xoa-driver)
+
+## Key Features
+* Objected-oriented, high-level abstraction, to help users save time on parsing command responses.
+* Supporting sending commands in batches to increase code execution efficiency.
+* Automatically matching command requests and server response, providing clear information in case a command gets an error response.
+* Supporting server-to-client push notification, and event subscription, to reduce user code complexity.
+* Covering commands of Xena testers, including Xena Valkyrie, Vulcan, and Chimera.
+* Supporting IDE auto-complete with built-in class/function/API use manual, to increase development efficiency.

{tdl_xoa_driver-1.5.0 → tdl_xoa_driver-1.5.0b1}/setup.py

@@ -8,7 +8,7 @@ def main():
     setuptools.setup(
         name="tdl-xoa-driver",
         description=(
-            "TDL XOA Python API is a Python library providing user-friendly communication"
+            "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."

{tdl_xoa_driver-1.5.0 → tdl_xoa_driver-1.5.0b1/tdl_xoa_driver.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: tdl-xoa-driver
-Version: 1.5.0
-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.
+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.
 Home-page: https://github.com/xenanetworks/tdl-xoa-driver
 Author: Leonard Yu, Zoltan Hanisch
 Author-email: Leonard.Yu@teledyne.com, Zoltan.Hanisch@teledyne.com
@@ -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)
-# 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.
+# 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.
 
 ## Introduction
-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 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 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.
+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.
 
-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.
+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.
 
 ## Documentation
 The user documentation is hosted:

{tdl_xoa_driver-1.5.0 → tdl_xoa_driver-1.5.0b1}/tdl_xoa_driver.egg-info/SOURCES.txt

@@ -29,7 +29,7 @@ xoa_driver/functions/cli/_cli_manager.py
 xoa_driver/functions/cli/_config_block.py
 xoa_driver/functions/cli/_socket_driver.py
 xoa_driver/functions/cli/port_config.py
-xoa_driver/functions/cli/testbed_config.py
+xoa_driver/functions/cli/test_case_config.py
 xoa_driver/functions/cmis/__init__.py
 xoa_driver/functions/cmis/_constants.py
 xoa_driver/functions/cmis/_replies.py
@@ -155,7 +155,6 @@ xoa_driver/internals/hli/modules/modules_l23/module_l23_base.py
 xoa_driver/internals/hli/ports/__init__.py
 xoa_driver/internals/hli/ports/base_port.py
 xoa_driver/internals/hli/ports/port_l23/__init__.py
-xoa_driver/internals/hli/ports/port_l23/edun_l1.py
 xoa_driver/internals/hli/ports/port_l23/family_combi.py
 xoa_driver/internals/hli/ports/port_l23/family_d.py
 xoa_driver/internals/hli/ports/port_l23/family_e.py

{tdl_xoa_driver-1.5.0 → tdl_xoa_driver-1.5.0b1}/xoa_driver/__init__.py

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

{tdl_xoa_driver-1.5.0 → tdl_xoa_driver-1.5.0b1}/xoa_driver/functions/cli/__init__.py

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

{tdl_xoa_driver-1.5.0 → tdl_xoa_driver-1.5.0b1}/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
 

{tdl_xoa_driver-1.5.0 → tdl_xoa_driver-1.5.0b1}/xoa_driver/functions/cli/port_config.py

@@ -1,11 +1,10 @@
 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 port config to the specified filepath
+    """Save configuration from the test port to the specified filepath
 
     :param tester: Chassis object
     :type tester: testers.L23Tester
@@ -49,12 +48,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+') as xpcfile:
+    with open(path, 'w+', newline='') 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) -> List[Tuple[str, str]]:
-    """Load port config from the specified filepath
+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
 
     :param tester: Chassis object
     :type tester: testers.L23Tester
@@ -62,8 +61,6 @@ 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
@@ -80,10 +77,8 @@ 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', encoding='utf-8') as xpcfile:
+    with open(path, 'r', newline='') as xpcfile:
         config_data = xpcfile.read()
 
     # Deserialize config block and send CLI commands
@@ -92,14 +87,12 @@ 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
-            resp = xm.send(cmd=f"{port_index} {cmd}", sync_on=False)
-            result.append((resp, f"{port_index} {cmd}"))
+            xm.send(cmd=f"{port_index} {cmd}", sync_on=False)
 
     # 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) -> List[Tuple[str, str]]:
+async def port_config_from_file(tester: testers.L23Tester, port: ports.GenericL23Port, path: str, debug=False, halt_on_error=False) -> None:
     """Load port configuration from the specifiied filepath. This function is a wrapper around load_port_config to provide backward compatibility.
 
     :param tester: Chassis object
@@ -108,9 +101,7 @@ 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]]
     """
-    return await load_port_config(tester, port, path, debug=debug, halt_on_error=halt_on_error)
+    await load_port_config(tester, port, path, debug=debug, halt_on_error=halt_on_error)
 
 

tdl_xoa_driver-1.5.0/xoa_driver/functions/cli/testbed_config.py → tdl_xoa_driver-1.5.0b1/xoa_driver/functions/cli/test_case_config.py

@@ -1,12 +1,12 @@
 import asyncio
 from xoa_driver import testers, modules, ports
 from ._cli_manager import XOACLIManager
-from typing import List, Tuple
+from typing import List
 from ..mgmt import *
 from ._config_block import *
 
-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
+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
 
     :param tester: Chassis object
     :type tester: testers.L23Tester
@@ -90,13 +90,13 @@ async def save_testbed_config(tester: testers.L23Tester, ports: List[ports.Gener
         port_config_block.commands = raw_resp[0]
         result += "\n" + ";\n" + port_config_block.config_block_str
         
-    with open(path, 'w+') as xtcfile:
+    with open(path, 'w+', newline='') as xtcfile:
         xtcfile.write(result)
     
     return result
 
-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
+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
 
     :param tester: Chassis object
     :type tester: testers.L23Tester
@@ -106,8 +106,6 @@ async def load_testbed_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
@@ -120,55 +118,50 @@ async def load_testbed_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') as xpcfile:
+    with open(path, 'r', newline='') 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}")
-                    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]]:
+        # 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:
     """Load module configuration from the specifiied filepath. This function is a wrapper around load_module_config to provide backward compatibility.
 
     :param tester: Chassis object
@@ -176,4 +169,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
     """
-    return await load_testbed_config(tester, path, mode="module", debug=debug, halt_on_error=halt_on_error)
+    await load_test_case_config(tester, path, mode="module", debug=debug, halt_on_error=halt_on_error)

{tdl_xoa_driver-1.5.0 → tdl_xoa_driver-1.5.0b1}/xoa_driver/internals/commands/p_commands.py

@@ -601,44 +601,7 @@ 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]:
@@ -1549,6 +1512,7 @@ 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))