tdl-xoa-driver 1.6.2__tar.gz → 1.7.1__tar.gz

{tdl_xoa_driver-1.6.2/tdl_xoa_driver.egg-info → tdl_xoa_driver-1.7.1}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: tdl-xoa-driver
-Version: 1.6.2
+Version: 1.7.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: Teledyne LeCroy
 Maintainer-email: xena-sales@teledyne.com
 License: Apache 2.0
 Classifier: Development Status :: 5 - Production/Stable

{tdl_xoa_driver-1.6.2 → tdl_xoa_driver-1.7.1}/setup.py

@@ -17,7 +17,7 @@ def main():
         long_description_content_type="text/markdown",
         author="Leonard Yu, Zoltan Hanisch",
         author_email="Leonard.Yu@teledyne.com, Zoltan.Hanisch@teledyne.com",
-        maintainer="Teledyne LeCroy Xena",
+        maintainer="Teledyne LeCroy",
         maintainer_email="xena-sales@teledyne.com",
         url="https://github.com/xenanetworks/tdl-xoa-driver",
         packages=setuptools.find_packages(),

{tdl_xoa_driver-1.6.2 → tdl_xoa_driver-1.7.1/tdl_xoa_driver.egg-info}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: tdl-xoa-driver
-Version: 1.6.2
+Version: 1.7.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: Teledyne LeCroy
 Maintainer-email: xena-sales@teledyne.com
 License: Apache 2.0
 Classifier: Development Status :: 5 - Production/Stable

{tdl_xoa_driver-1.6.2 → tdl_xoa_driver-1.7.1}/tdl_xoa_driver.egg-info/SOURCES.txt

@@ -20,8 +20,10 @@ xoa_driver/utils.py
 xoa_driver/functions/__init__.py
 xoa_driver/functions/anlt.py
 xoa_driver/functions/anlt_ll_debug.py
+xoa_driver/functions/async_wrapper.py
 xoa_driver/functions/exceptions.py
 xoa_driver/functions/headers.py
+xoa_driver/functions/layer1_adv.py
 xoa_driver/functions/mgmt.py
 xoa_driver/functions/tools.py
 xoa_driver/functions/cli/__init__.py
@@ -55,6 +57,7 @@ xoa_driver/internals/commands/ped_commands.py
 xoa_driver/internals/commands/pef_commands.py
 xoa_driver/internals/commands/pf_commands.py
 xoa_driver/internals/commands/pl1_commands.py
+xoa_driver/internals/commands/pl1ad_commands.py
 xoa_driver/internals/commands/pl_commands.py
 xoa_driver/internals/commands/pm_commands.py
 xoa_driver/internals/commands/pp_commands.py
@@ -154,6 +157,7 @@ xoa_driver/internals/hli/ports/port_l23/family_odin.py
 xoa_driver/internals/hli/ports/port_l23/family_thor.py
 xoa_driver/internals/hli/ports/port_l23/layer1_edun.py
 xoa_driver/internals/hli/ports/port_l23/layer1_freya.py
+xoa_driver/internals/hli/ports/port_l23/layer1_freya_adv.py
 xoa_driver/internals/hli/ports/port_l23/layer1_loki.py
 xoa_driver/internals/hli/ports/port_l23/layer1_thor.py
 xoa_driver/internals/hli/ports/port_l23/bases/__init__.py
@@ -186,6 +190,10 @@ xoa_driver/internals/hli/ports/port_l23/layer1/prbs.py
 xoa_driver/internals/hli/ports/port_l23/layer1/preamble.py
 xoa_driver/internals/hli/ports/port_l23/layer1/rs_fault.py
 xoa_driver/internals/hli/ports/port_l23/layer1/siv.py
+xoa_driver/internals/hli/ports/port_l23/layer1_adv/__init__.py
+xoa_driver/internals/hli/ports/port_l23/layer1_adv/freq.py
+xoa_driver/internals/hli/ports/port_l23/layer1_adv/pcs_fec.py
+xoa_driver/internals/hli/ports/port_l23/layer1_adv/rs_fault.py
 xoa_driver/internals/hli/ports/port_l23/sec/__init__.py
 xoa_driver/internals/hli/ports/port_l23/sec/macsec.py
 xoa_driver/internals/hli/ports/port_l23/tcvr/__init__.py

tdl_xoa_driver-1.7.1/xoa_driver/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "1.7.1"
+__short_version__ = "1.7"

{tdl_xoa_driver-1.6.2 → tdl_xoa_driver-1.7.1}/xoa_driver/enums.py

@@ -200,6 +200,7 @@ from .internals.commands.enums import (
     ModifierEndianness,
     MACSecPNMode,
     ModuleConfigStatus,
+    TrueFalse,
 )
 
 __all__ = (
@@ -400,4 +401,5 @@ __all__ = (
     "ModifierEndianness",
     "MACSecPNMode",
     "ModuleConfigStatus",
+    "TrueFalse",
 )

tdl_xoa_driver-1.7.1/xoa_driver/functions/async_wrapper.py

@@ -0,0 +1,130 @@
+
+"""
+ASYNC WRAPPER
+
+The APIs provided by tdl-xoa-driver are async functions. 
+This means any function that uses the tdl-xoa-driver must be 
+declared as async. 
+
+This might be a problem for you if your existing framework 
+doesn't support async functions. To solve this "incompatibility" 
+issue, we have made an async wrapper class **XenaAsyncWrapper** 
+for you to wrap tdl-xoa-driver's async function inside and use it 
+as a regular Python function.
+"""
+
+from typing import Any, Awaitable, Callable, TypeVar
+import asyncio
+import threading
+import queue
+
+T = TypeVar("T")
+
+class XenaAsyncWrapper:
+    """This is a wrapper class that encapsulates XOA asyncio functions 
+    so you can use the APIs in a non-async fashion.
+
+    Example:
+
+    .. code-block:: python
+        
+        import asyncio
+        from xoa_driver import testers, modules, ports
+        from xoa_driver.hlfuncs import mgmt, async_wrapper
+
+        # initialize async wrapper
+        xaw = async_wrapper.XenaAsyncWrapper()
+
+        # check if it starts to work
+        while not xaw.is_thread_started():
+            time.sleep(0.01)
+
+        # create a tester instance
+        # this will automatically create a tcp connection to the tester
+        tester = xaw(testers.L23Tester(host=CHASSIS_IP, username=USERNAME))
+
+        # obtain a module instance
+        module = tester.modules.obtain(MODULE_IDX)
+
+        # Obtain a port from the module
+        port = module.ports.obtain(PORT_IDX)
+
+        # reserve & reset port
+        xaw(mgmt.reserve_ports(ports=[port], reset=True))
+
+        xaw(asyncio.sleep(5))
+
+        # create a stream
+        stream = xaw(port.streams.create())
+        xaw(utils.apply(
+            stream.enable.set_on(),
+            stream.comment.set(f"Stream A to B"),
+            stream.rate.pps.set(stream_rate_pps=10000),
+            stream.packet.length.set(length_type=enums.LengthType.FIXED, min_val=1000, max_val=1000),
+            stream.tpld_id.set(test_payload_identifier = 0))
+            )
+        
+        # start and stop traffic
+        xaw(port.traffic.state.set_start())
+        time.sleep(TRAFFIC_DURATION)
+        xaw(port.traffic.state.set_stop())
+        time.sleep(COOLDOWN_DURATION)
+
+    """
+
+    
+    __slots__ = ("loop", "thread", "_events")
+
+    def __init__(self) -> None:
+        self.loop: asyncio.AbstractEventLoop | None = None
+        self.thread = threading.Thread(target=self._run_event_loop)
+        self.thread.start()
+        self._events = queue.Queue()
+
+    def _run_event_loop(self):
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self.loop)
+        self.loop.run_forever()
+
+    def run_coroutine_threadsafe(self, coro: Awaitable[T]) -> T:
+        if not self.loop:
+            raise RuntimeError("Event loop is not running")
+        future_ = asyncio.run_coroutine_threadsafe(coro, self.loop)
+        if exc := future_.exception():
+            raise exc
+        return future_.result()
+
+    def is_thread_started(self) -> bool:
+        return self.loop is not None and self.loop.is_running()
+
+    def close(self) -> None:
+        if not self.loop:
+            return None
+        self.loop.call_soon_threadsafe(self.loop.stop)
+        self.thread.join()
+
+    def __call__(self, coro):
+        if self.loop is None:
+            raise RuntimeError("Thread not started")
+
+        event = asyncio.Event()
+
+        def _callback(fut):
+            self._events.put((fut.result(), fut.exception()))
+            assert self.loop is not None  # Type guard for type checker
+            self.loop.call_soon_threadsafe(event.set)
+
+        async def _runner():
+            try:
+                fut = asyncio.ensure_future(coro)
+                fut.add_done_callback(_callback)
+                await event.wait()
+            except Exception as exc:
+                self._events.put((None, exc))
+
+        asyncio.run_coroutine_threadsafe(_runner(), self.loop)
+        result, exc = self._events.get()
+
+        if exc:
+            raise exc
+        return result

tdl_xoa_driver-1.7.1/xoa_driver/functions/layer1_adv.py

@@ -0,0 +1,340 @@
+"""
+The Advanced Layer 1 functions
+"""
+
+from __future__ import annotations
+import asyncio
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Union,
+    List,
+    Tuple,
+)
+if TYPE_CHECKING:
+    from xoa_driver.ports import Z800FreyaPort, Z1600EdunPort
+    from xoa_driver.modules import Z800FreyaModule, Z1600EdunModule
+    FreyaEdunModule = Union[Z800FreyaModule, Z1600EdunModule]
+    FreyaEdunPort = Union[Z800FreyaPort, Z1600EdunPort]
+
+from ..utils import apply
+
+
+
+async def get_tx_freq_curr(port: "Z800FreyaPort") -> int:
+    """
+    Get the current Tx frequency in Hz of the specified port.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :return: The current Tx frequency in Hz.
+    :rtype: int
+    """
+
+    resp = await port.layer1_adv.freq.tx_curr.get()
+    return resp.frequency_hz*10
+
+
+async def get_rx_freq_curr(port: "Z800FreyaPort") -> int:
+    """
+    Get the current Rx frequency in Hz of the specified port.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :return: The current Rx frequency in Hz.
+    :rtype: int
+    """
+    resp = await port.layer1_adv.freq.rx_curr.get()
+    return resp.frequency_hz
+
+
+async def get_rx_freq_min(port: "Z800FreyaPort") -> int:
+    """
+    Get the minimum Rx frequency in Hz since last query.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :return: The minimum Rx frequency in Hz since last query.
+    :rtype: int
+    """
+    resp = await port.layer1_adv.freq.rx_min.get()
+    return resp.frequency_hz
+
+
+async def get_rx_freq_max(port: "Z800FreyaPort") -> int:
+    """
+    Get the maximum Rx frequency in Hz since last query.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :return: The maximum Rx frequency in Hz since last query.
+    :rtype: int
+    """
+    resp = await port.layer1_adv.freq.rx_max.get()
+    return resp.frequency_hz
+
+
+async def get_rx_freq_all(port: "Z800FreyaPort") -> Tuple[int, int, int]:
+    """
+    Get the current, minimum, and maximum Rx frequencies in Hz of the specified port.
+
+    The minimum and maximum values are since last query.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :return: The current, minimum, and maximum Rx frequencies in Hz of the specified port.
+    :rtype: Tuple[int, int, int]
+    """
+
+    resp1, resp2, resp3 = await apply(
+        port.layer1_adv.freq.rx_curr.get(),
+        port.layer1_adv.freq.rx_min.get(),
+        port.layer1_adv.freq.rx_max.get(),
+    )
+
+    return (resp1.frequency_hz, resp2.frequency_hz, resp3.frequency_hz)
+
+
+async def get_cdr_lol_since_last(port: "Z800FreyaPort", serdes_indices: List[int]) -> List[Tuple[bool, bool]]:
+    """
+    Get the current and latched CDR LOL status of the specified Serdes.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :param serdes_indices: The indices of the Serdes.
+    :type serdes_indices: List[int]
+    :return: A list of tuples containing current and latched CDR LOL status for each Serdes.
+    :rtype: List[Tuple[bool, bool]]
+    """
+    results = []
+    cmds = []
+    for serdes_id in serdes_indices:
+        cmds.append(port.layer1_adv.serdes[serdes_id].rx_cdr_lol_since_last.get())
+    resps = await apply(*cmds)
+    for resp in resps:
+        curr = True if resp.current_lol.value == 1 else False
+        latched = True if resp.latched_lol.value == 1 else False
+        results.append((curr, latched))
+    return results
+
+
+async def get_rx_lane_skew(port: "Z800FreyaPort", lane_indices: List[int]) -> List[int]:
+    """Get Rx relative skew measured in bits of the specified PCS lanes.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :param lane_indices: The indices of the PCS lanes.
+    :type lane_indices: List[int]
+    :return: Relative skew of the specified PCS lanes measured in bits
+    :rtype: List[int]
+    """
+    results = []
+    cmds = []
+    for lane in lane_indices:
+        cmds.append(port.layer1_adv.pcs.lane[lane].rx_skew.get())
+    resps = await apply(*cmds)
+    for resp in resps:
+        results.append(resp.skew_bits)
+    return results
+
+
+async def get_hi_ber(port: "Z800FreyaPort") -> Tuple[bool, bool]:
+    """
+    Get the current and latched HI-BER status of the specified port.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :return: A tuple containing current and latched HI-BER status.
+    :rtype: Tuple[bool, bool]
+    """
+    resp = await port.layer1_adv.pcs.hi_ber.status.get()
+    curr = True if resp.current_hiber.value == 1 else False
+    latched = True if resp.latched_hiber.value == 1 else False
+    return (curr, latched)
+
+
+async def get_hi_ser(port: "Z800FreyaPort") -> Tuple[bool, bool]:
+    """
+    Get the current and latched HI-SER status of the specified port.
+
+    HI-SER is signalled if 5560 RS-FEC symbol errors are detected in contiguous block of 8192 non-overlapping RS-FEC codewords.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :return: A tuple containing current and latched HI-SER status.
+    :rtype: Tuple[bool, bool]
+    """
+    resp = await port.layer1_adv.pcs.hi_ser.status.get()
+    curr = True if resp.current_hiser.value == 1 else False
+    latched = True if resp.latched_hiser.value == 1 else False
+    return (curr, latched)
+
+
+async def get_deg_ser(port: "Z800FreyaPort") -> Tuple[bool, bool]:
+    """
+    Get the current and latched Degraded SER status of the specified port.
+
+    The thresholds for signaling Degraded SER is programmable using
+    :py:func:`set_deg_ser_thresholds`.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :return: A tuple containing current and latched Degraded SER status.
+    :rtype: Tuple[bool, bool]
+    """
+    resp = await port.layer1_adv.pcs.deg_ser.status.get()
+    curr = True if resp.current_deg_ser.value == 1 else False
+    latched = True if resp.latched_deg_ser.value == 1 else False
+    return (curr, latched)
+
+
+async def set_deg_ser_thresholds(port: "Z800FreyaPort", activate_threshold: int, deactivate_threshold: int, interval: int) -> None:
+    """
+    Configure signaling Degraded SER thresholds of the port.
+
+    If more than `activate_threshold` number of RS-FEC symbol errors are detected
+    in a contiguous block of `interval` RS-FEC codewords, Degraded SER
+    is signalled on the port.
+
+    If less than `deactivate_threshold` number of RS-FEC symbol errors are detected
+    in a contiguous block of `interval` RS-FEC codewords, Degraded SER
+    is no longer signalled on the port.
+
+    `interval` must be an even number and a multiple of the number of PCS flows:
+
+        - 100G:      2 (one flow, but must be even)
+        - 200G/400G: 2 (two flows)
+        - 800G/1.6T: 4 (four flows)
+
+    An uncorrectable codeword is counted as 16 erroneous RS-FEC symbols.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :param activate_threshold: The activate threshold.
+    :type activate_threshold: int
+    :param deactivate_threshold: The deactivate threshold.
+    :type deactivate_threshold: int
+    :param interval: The interval.
+    :type interval: int
+    """
+    await port.layer1_adv.pcs.deg_ser.threshold.set(
+        act_thresh=activate_threshold,
+        deact_thresh=deactivate_threshold,
+        degrade_interval=interval,
+    )
+
+
+async def get_deg_ser_thresholds(
+    port: "Z800FreyaPort",
+) -> Tuple[int, int, int]:
+    """
+    Get signaling Degraded SER thresholds of the port.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :return: A tuple containing activate threshold, deactivate threshold, and interval.
+    :rtype: Tuple[int, int, int]
+    """
+    resp = await port.layer1_adv.pcs.deg_ser.threshold.get()
+
+    return (resp.act_thresh, resp.deact_thresh, resp.degrade_interval)
+
+
+async def get_cw_err_since_last(port: "Z800FreyaPort") -> int:
+    """
+    Get the number of erroneous 64b/66b codewords since the previous query per port.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :return: Number of erroneous 64b/66b codewords since the previous query per port.
+    :rtype: int
+    """
+    resp = await port.layer1_adv.pcs.err_cw.rx_err_cw_since_last.get()
+    return resp.err_cw_count
+
+
+async def get_itb_since_last(port: "Z800FreyaPort") -> int:
+    """
+    Get the number of invalid 256b/257b transcode blocks since the previous query per port.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :return: Number of invalid 256b/257b transcode blocks since the previous query per port.
+    :rtype: int
+    """
+    resp = await port.layer1_adv.pcs.itb.rx_itb_since_last.get()
+    return resp.itb_count
+
+
+async def get_link_sync_loss_since_last(port: "Z800FreyaPort") -> int:
+    """
+    Get the number of cumulated link sync loss events since the previous query per port.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :return: Number of cumulated link sync loss events since the previous query per port.
+    :rtype: int
+    """
+    resp = await port.layer1_adv.pcs.rx_link_sync_loss_since_last.get()
+    return resp.losync_count
+
+
+async def get_local_fault_since_last(port: "Z800FreyaPort") -> int:
+    """
+    Get the number of cumulated local fault conditions since the previous query per port.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :return: Number of cumulated local fault conditions since the previous query per port.
+    :rtype: int
+    """
+    resp = await port.layer1_adv.rs_fault.rx_local_fault_since_last.get()
+    return resp.lf_count
+
+
+async def get_remote_fault_since_last(port: "Z800FreyaPort") -> int:
+    """
+    Get the number of cumulated remote fault conditions since the previous query per port.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :return: Number of cumulated remote fault conditions since the previous query per port.
+    :rtype: int
+    """
+    resp = await port.layer1_adv.rs_fault.rx_remote_fault_since_last.get()
+    return resp.rf_count
+
+
+async def get_total_loa_since_last(port: "Z800FreyaPort") -> int:
+    """
+    Get the number of cumulated Loss of Alignment (LOA) events since the previous query per port.
+
+    :param port: The port instance.
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
+    :return: Number of cumulated Loss of Alignment (LOA) events since the previous query per port.
+    :rtype: int
+    """
+    resp = await port.layer1_adv.pcs.rx_total_loa_since_last.get()
+    return resp.loa_count
+
+
+__all__ = (
+    "get_tx_freq_curr",
+    "get_rx_freq_curr",
+    "get_rx_freq_min",
+    "get_rx_freq_max",
+    "get_rx_freq_all",
+    "get_cdr_lol_since_last",
+    "get_rx_lane_skew",
+    "get_hi_ber",
+    "get_hi_ser",
+    "get_deg_ser",
+    "set_deg_ser_thresholds",
+    "get_deg_ser_thresholds",
+    "get_cw_err_since_last",
+    "get_itb_since_last",
+    "get_link_sync_loss_since_last",
+    "get_local_fault_since_last",
+    "get_remote_fault_since_last",
+    "get_total_loa_since_last",
+)