tdl-xoa-driver 1.5.0b2__py3-none-any.whl → 1.6.0__py3-none-any.whl

xoa_driver/functions/anlt.py

@@ -1,13 +1,17 @@
 """The anlt high-level function module."""
-
 from __future__ import annotations
 from dataclasses import dataclass, field
-import typing as t
+from typing import (
+    TYPE_CHECKING,
+    Union,
+    Any,
+    Generator,
+    List,
+)
+if TYPE_CHECKING:
+    from xoa_driver.ports import Z800FreyaPort
 from xoa_driver import enums
 from xoa_driver.utils import apply
-from xoa_driver.internals.hli.ports.port_l23.family_l import FamilyL
-from xoa_driver.internals.hli.ports.port_l23.family_l1 import FamilyFreya
-from xoa_driver.ports import GenericL23Port
 from xoa_driver.lli import commands
 from xoa_driver.internals.core import interfaces as itf
 from xoa_driver.misc import Token
@@ -23,14 +27,9 @@ from .tools import (
 )
 import asyncio
 
-PcsPmaSupported = (FamilyL, FamilyFreya)
-AutoNegSupported = (FamilyL, FamilyFreya)
-LinkTrainingSupported = FamilyL
-
-
 @dataclass
 class DoAnlt:
-    port: GenericL23Port
+    port: "Z800FreyaPort"
     """port object"""
     should_do_an: bool
     """should the port do autoneg?"""
@@ -117,7 +116,7 @@ class DoAnlt:
 
         return _an_mode, _lt_mode, _timeout_mode
 
-    def __builder__(self) -> t.Generator[Token, None, None]:
+    def __builder__(self) -> Generator[Token, None, None]:
         """Defining commands sequence"""
         
         # # Set autoneg timeout
@@ -169,7 +168,7 @@ class DoAnlt:
 
 
 async def anlt_start(
-    port: GenericL23Port,
+    port: "Z800FreyaPort",
     should_do_an: bool,
     should_do_lt: bool,
     an_allow_loopback: bool,
@@ -180,12 +179,10 @@ async def anlt_start(
     should_enable_lt_timeout: bool,
 ) -> None:
     """
-    .. versionchanged:: 2.5
-
     Start ANLT on a port
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :param should_do_an: should the port do autoneg?
     :type should_do_an: bool
     :param should_do_lt: should the port do link training?
@@ -218,14 +215,12 @@ async def anlt_start(
     await anlt.run()
 
 
-async def autoneg_status(port: GenericL23Port) -> dict[str, t.Any]:
+async def autoneg_status(port: "Z800FreyaPort") -> dict[str, Any]:
     """
-    .. versionchanged:: 2.5
-
     Get the auto-negotiation status
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :return:
     :rtype: typing.Dict[str, typing.Any]
     """
@@ -240,7 +235,7 @@ async def autoneg_status(port: GenericL23Port) -> dict[str, t.Any]:
     return dictionize_autoneg_status(loopback, auto_neg_info, status)
 
 
-LinkTrainType = t.Union[
+LinkTrainType = Union[
     enums.LinkTrainCoeffs,
     enums.LinkTrainPresets,
     enums.LinkTrainEncoding,
@@ -249,7 +244,7 @@ LinkTrainType = t.Union[
 
 
 async def __lt_coeff(
-    port: GenericL23Port,
+    port: "Z800FreyaPort",
     serdes: int,
     arg: LinkTrainType,
     *,
@@ -268,7 +263,7 @@ async def __lt_coeff(
 
 
 async def lt_coeff_inc(
-    port: GenericL23Port,
+    port: "Z800FreyaPort",
     serdes: int,
     emphasis: enums.LinkTrainCoeffs
 ) -> enums.LinkTrainCmdResults:
@@ -276,7 +271,7 @@ async def lt_coeff_inc(
     Ask the remote port to increase coeff of the specified serdes.
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :param serdes: the serdes index, starting from 0
     :type serdes: int
     :param emphasis: the emphasis to increase
@@ -288,7 +283,7 @@ async def lt_coeff_inc(
 
 
 async def lt_coeff_dec(
-    port: GenericL23Port,
+    port: "Z800FreyaPort",
     serdes: int,
     emphasis: enums.LinkTrainCoeffs
 ) -> enums.LinkTrainCmdResults:
@@ -296,7 +291,7 @@ async def lt_coeff_dec(
     Ask the remote port to decrease coeff of the specified serdes.
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :param serdes: the serdes index, starting from 0
     :type serdes: int
     :param emphasis: the emphasis to decrease
@@ -308,7 +303,7 @@ async def lt_coeff_dec(
 
 
 async def lt_coeff_no_eq(
-    port: GenericL23Port,
+    port: "Z800FreyaPort",
     serdes: int,
     emphasis: enums.LinkTrainCoeffs
 ) -> enums.LinkTrainCmdResults:
@@ -317,7 +312,7 @@ async def lt_coeff_no_eq(
     Ask the remote port to set the coeff to NO_EQ on the specified serdes.
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :param serdes: the serdes index, starting from 0
     :type serdes: int
     :param emphasis: the emphasis to set to NO_EQ
@@ -329,7 +324,7 @@ async def lt_coeff_no_eq(
 
 
 async def lt_preset(
-    port: GenericL23Port,
+    port: "Z800FreyaPort",
     serdes: int,
     preset: enums.LinkTrainPresets
 ) -> enums.LinkTrainCmdResults:
@@ -337,7 +332,7 @@ async def lt_preset(
     Ask the remote port to use the preset of the specified serdes.
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :param serdes: the serdes index, starting from 0
     :type serdes: int
     :param preset: preset index to select for the serdes, 0,1,2,3,4,
@@ -349,7 +344,7 @@ async def lt_preset(
 
 
 async def lt_encoding(
-    port: GenericL23Port,
+    port: "Z800FreyaPort",
     serdes: int,
     encoding: enums.LinkTrainEncoding
 ) -> enums.LinkTrainCmdResults:
@@ -357,7 +352,7 @@ async def lt_encoding(
     Ask the remote port to use the encoding of the specified serdes.
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :param serdes: the serdes index, starting from 0
     :type serdes: int
     :param encoding: link training encoding
@@ -368,12 +363,12 @@ async def lt_encoding(
     return await __lt_coeff(port, serdes, encoding, cmd=enums.LinkTrainCmd.CMD_ENCODING)
 
 
-async def lt_trained(port: GenericL23Port, serdes: int) -> enums.LinkTrainCmdResults:
+async def lt_trained(port: "Z800FreyaPort", serdes: int) -> enums.LinkTrainCmdResults:
     """
     Tell the remote port that the current serdes is trained.
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :param serdes: the serdes index, starting from 0
     :type serdes: int
     :return:
@@ -387,14 +382,12 @@ async def lt_trained(port: GenericL23Port, serdes: int) -> enums.LinkTrainCmdRes
     )
 
 
-async def lt_status(port: GenericL23Port, serdes: int) -> dict[str, t.Any]:
+async def lt_status(port: "Z800FreyaPort", serdes: int) -> dict[str, Any]:
     """
-    .. versionchanged:: 2.5
-
     Show the link training status.
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :param serdes: the serdes index, starting from 0
     :type serdes: int
     :return: LT status of the serdes
@@ -419,12 +412,12 @@ async def lt_status(port: GenericL23Port, serdes: int) -> dict[str, t.Any]:
     )
 
 
-async def txtap_get(port: GenericL23Port, serdes: int) -> dict[str, int]:
+async def txtap_get(port: "Z800FreyaPort", serdes: int) -> dict[str, int]:
     """
     Get the tap value of the local TX tap.
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :param serdes: the serdes index, starting from 0
     :type serdes: int
     :return: tap values of the serdes
@@ -436,19 +429,19 @@ async def txtap_get(port: GenericL23Port, serdes: int) -> dict[str, int]:
 
 
 async def txtap_set(
-    port: GenericL23Port,
+    port: "Z800FreyaPort",
     serdes: int,
     pre3: int,
     pre2: int,
     pre: int,
     main: int,
-    post1: int,
+    post: int,
 ) -> None:
     """
     Set the tap value of the local TX tap.
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :param serdes: the serdes index, starting from 0
     :type serdes: int
     :param pre3: pre3 value
@@ -459,29 +452,22 @@ async def txtap_set(
     :type pre: int
     :param main: main value
     :type main: int
-    :param post1: post1 value
-    :type post1: int
+    :param post: post value
+    :type post: int
     :return:
     :rtype: None
     """
     conn, mid, pid = get_ctx(port)
     cmd_ = commands.PP_PHYTXEQ(conn, mid, pid, serdes)
-    await cmd_.set(
-        pre=pre,
-        main=main,
-        post=post1,
-        pre2=pre2,
-        pre3_post2=pre3,
-        post3=0,
-    )
+    await cmd_.set(tap_values=[pre, main, post, pre2, pre3])
 
 
-async def anlt_link_recovery(port: GenericL23Port, restart_link_down: bool, restart_lt_failure: bool) -> None:
+async def anlt_link_recovery(port: "Z800FreyaPort", restart_link_down: bool, restart_lt_failure: bool) -> None:
     """
     This command manages the auto-restart features.
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :param restart_link_down: enable AN+LT auto-restart when a link down condition is detected. A "link down" state signifies the loss of a valid input signal, which can occur due to events such as cable unplugging and re-plugging, TX disable, or link flap on the link partner's end. The auto-restart process will continue until the link is re-established. Please note that this setting is only effective when AN and/or LT are enabled.
     :type restart_link_down: bool
     :param restart_lt_failure: if LT is enabled and experiences a failure on either side, the port will initiate the AN+LT restart process repeatedly until LT succeeds. This functionality is only applicable when LT is enabled.
@@ -501,14 +487,12 @@ async def anlt_link_recovery(port: GenericL23Port, restart_link_down: bool, rest
     await cmd_.set(values=[param])
 
 
-async def anlt_status(port: GenericL23Port) -> dict[str, t.Any]:
+async def anlt_status(port: "Z800FreyaPort") -> dict[str, Any]:
     """
-    .. versionchanged:: 2.5
-
     Get the overview of ANLT status
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :return: AN/LT status of the port
     :rtype: typing.Dict[str, typing.Any]
     """
@@ -529,12 +513,12 @@ async def anlt_status(port: GenericL23Port) -> dict[str, t.Any]:
     return dictionize_anlt_status(_link_recovery, _anlt_op, _linktrain_cfg, _capabilities, _allow_loopback)
 
 
-async def anlt_log(port: GenericL23Port) -> str:
+async def anlt_log(port: "Z800FreyaPort") -> str:
     """
     Get the anlt log messages
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :return: AN/LT protocol log traces of the port
     :rtype: str
     """
@@ -543,14 +527,12 @@ async def anlt_log(port: GenericL23Port) -> str:
     return log.log_string
 
 
-async def anlt_stop(port: GenericL23Port) -> None:
+async def anlt_stop(port: "Z800FreyaPort") -> None:
     """
-    .. versionchanged:: 2.5
-
     Stop AN & LT
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     """
     conn, mid, pid = get_ctx(port)
 
@@ -560,12 +542,12 @@ async def anlt_stop(port: GenericL23Port) -> None:
         )
 
 
-async def txtap_autotune(port: GenericL23Port, serdes: int) -> None:
+async def txtap_autotune(port: "Z800FreyaPort", serdes: int) -> None:
     """
     Auto tune the tap value of the local TX tap.
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :param serdes: the serdes index, starting from 0
     :type serdes: int
     :return:
@@ -577,12 +559,12 @@ async def txtap_autotune(port: GenericL23Port, serdes: int) -> None:
     await phy_autotune.set(on_off=enums.OnOff.ON)
 
 
-async def lt_im_status(port: GenericL23Port) -> dict[str, t.Any]:
+async def lt_im_status(port: "Z800FreyaPort") -> dict[str, Any]:
     """
     Get LT initial modulation config
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :return: LT initial modulation configuration of the port
     :rtype: typing.Dict[str, typing.Any]
     """
@@ -599,12 +581,12 @@ async def lt_im_status(port: GenericL23Port) -> dict[str, t.Any]:
     return dictionize_lt_im_status(capabilities, initial_mods)
 
 
-async def lt_algorithm_status(port: GenericL23Port) -> dict[str, t.Any]:
+async def lt_algorithm_status(port: "Z800FreyaPort") -> dict[str, Any]:
     """
     Get LT initial modulation config
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :return: LT initial modulation configuration of the port
     :rtype: typing.Dict[str, typing.Any]
     """
@@ -621,12 +603,12 @@ async def lt_algorithm_status(port: GenericL23Port) -> dict[str, t.Any]:
     return dictionize_lt_algorithm_status(capabilities, algorithms)
 
 
-async def anlt_strict(port: GenericL23Port, enable: bool) -> None:
+async def anlt_strict(port: "Z800FreyaPort", enable: bool) -> None:
     """
     Should ANLT strict mode be enabled
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :param enable: should ANLT strict mode be enabled
     :type enable: bool
     :return:
@@ -645,14 +627,14 @@ async def anlt_strict(port: GenericL23Port, enable: bool) -> None:
         ).set(values=[param])
 
 
-async def anlt_log_control(port: GenericL23Port, types: t.List[enums.AnLtLogControl]) -> None:
+async def anlt_log_control(port: "Z800FreyaPort", types: List[enums.AnLtLogControl]) -> None:
     """
     Control what should be logged for ANLT by xenaserver
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :param types: control what should be logged for ANLT by xenaserver
-    :type types: t.List[enums.AnLtLogControl]
+    :type types: List[enums.AnLtLogControl]
     :return:
     :rtype:  None
     """
@@ -671,12 +653,12 @@ async def anlt_log_control(port: GenericL23Port, types: t.List[enums.AnLtLogCont
             enums.Layer1ConfigType.ANLT_LOG_CONTROL
         ).set(values=[param])
 
-async def anlt_log_control_get(port: GenericL23Port) -> dict[str, bool]:
+async def anlt_log_control_get(port: "Z800FreyaPort") -> dict[str, bool]:
     """
     Get ANLT log control config
 
     :param port: the port object
-    :type port: :class:`~xoa_driver.ports.GenericL23Port`
+    :type port: :class:`~xoa_driver.ports.Z800FreyaPort`
     :return: dict of log control status
     :rtype:  dict[str, bool]
     """

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/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
@@ -52,8 +53,8 @@ async def save_port_config(tester: testers.L23Tester, port: ports.GenericL23Port
         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') 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
@@ -95,8 +95,8 @@ async def save_test_case_config(tester: testers.L23Tester, ports: List[ports.Gen
     
     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') 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_modules([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)