cgse 0.16.12__tar.gz → 0.16.14__tar.gz

{cgse-0.16.12 → cgse-0.16.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgse
-Version: 0.16.12
+Version: 0.16.14
 Summary: Generic Common-EGSE: Commanding and monitoring lab equipment
 Author: IvS KU Leuven
 Maintainer-email: Rik Huygen <rik.huygen@kuleuven.be>, Sara Regibo <sara.regibo@kuleuven.be>

{cgse-0.16.12 → cgse-0.16.14}/libs/cgse-common/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-common"
-version = "0.16.12"
+version = "0.16.14"
 description = "Software framework to support hardware testing"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.16.12 → cgse-0.16.14}/libs/cgse-coordinates/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-coordinates"
-version = "0.16.12"
+version = "0.16.14"
 description = "Reference Frames and Coordinate Transofrmations for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.16.12 → cgse-0.16.14}/libs/cgse-core/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-core"
-version = "0.16.12"
+version = "0.16.14"
 description = "Core services for the CGSE framework"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.16.12 → cgse-0.16.14}/libs/cgse-core/src/egse/async_control.py

@@ -18,7 +18,6 @@ from rich.traceback import Traceback
 from egse.env import bool_env
 from egse.exceptions import InitialisationError
 from egse.log import logging
-from egse.process import ProcessStatus
 from egse.registry.client import AsyncRegistryClient
 from egse.system import Periodic
 from egse.system import get_current_location

{cgse-0.16.12 → cgse-0.16.14}/libs/cgse-core/src/egse/mixin.py

@@ -104,7 +104,7 @@ def add_cr_lf(cmd_string: str) -> str:
     return cmd_string
 
 
-def expand_kwargs(kwargs: Dict):
+def expand_kwargs(kwargs: Dict) -> str:
     """Expand keyword arguments and their values as 'key=value' separated by spaces."""
     return " ".join(f"{k}={v}" for k, v in kwargs.items())
 
@@ -121,6 +121,7 @@ def dynamic_command(
     *,
     cmd_type: str,  # required keyword-only argument
     cmd_string: str = None,
+    cmd_string_func: Callable = None,
     process_response: Callable = None,
     process_cmd_string: Callable = None,
     process_kwargs: Callable = None,
@@ -179,6 +180,7 @@ def dynamic_command(
     Args:
         cmd_type (str): one of 'read', 'write', 'query', or 'transaction' [required keyword]
         cmd_string (str): format string for the generation of the instrument command
+        cmd_string_func (Callable): DIY function that will create a command string
         process_response (Callable): function to process the response
         process_cmd_string (Callable): function to process the command string after substitution
         process_kwargs (Callable): function to expand the kwargs after substitution
@@ -192,8 +194,8 @@ def dynamic_command(
     if cmd_type not in COMMAND_TYPES:
         raise ValueError(f"Unknown type passed into dynamic command decorator: {type=}")
 
-    if cmd_type in ("write", "query", "transaction") and cmd_string is None:
-        raise ValueError(f"No cmd_string was provided for {cmd_type=}.")
+    if cmd_type in ("write", "query", "transaction") and cmd_string is None and cmd_string_func is None:
+        raise ValueError(f"No cmd_string nor a cmd_string_func was provided for {cmd_type=}.")
 
     def func_wrapper(func: Callable):
         """Adds the different static attributes."""
@@ -205,6 +207,9 @@ def dynamic_command(
         if cmd_string is not None:
             setattr(func, "__cmd_string", cmd_string)
 
+        if cmd_string_func is not None:
+            setattr(func, "__cmd_string_func", cmd_string_func)
+
         if process_response is not None:
             setattr(func, "__process_response", process_response)
 
@@ -250,11 +255,31 @@ class DynamicCommandMixin:
             raise AttributeError("Transport was not defined in sub-class of DynamicInterfaceMixin")
 
     @staticmethod
-    def create_command_string(func: Callable, template_str: str, *args, **kwargs):
+    def create_command_string(func: Callable, provider: str | Callable[..., str], *args, **kwargs) -> str:
         """
-        Creates a command string that is understood by the instrument. This can be an SCPI
-        command or a specific proprietary command string. The `cmd_str` can contain placeholders
-        similar to what is used in string formatting.
+        Create the instrument command string from a template or from a provider callable.
+
+        The resulting string can be an SCPI command or a specific proprietary command string.
+
+        The `provider` argument controls how the raw command string is produced:
+
+        - If `provider` is a **callable**, it is invoked as `provider(*args, **kwargs)` and must
+          return the fully formed command string. This allows arbitrary construction logic
+          (e.g. conditional pieces, lookups, or complex formatting) outside the template
+          mechanics used below.
+
+        - If `provider` is a **string**, it is treated as a template and variables are
+          substituted from the bound arguments of `func`. Two string styles are supported:
+
+            - Template style using `string.Template` with `$name` placeholders (safe substitution).
+            - Format style using `str.format` with `{name}` placeholders, activated when
+              the wrapped `func` has the `__use_format` attribute set.
+
+          The code binds `args` and `kwargs` to `func`'s signature to produce a mapping of
+          parameter names to values. For parameters declared as `**kwargs` the mixin will
+          expand them with a `__process_kwargs` callable if present on `func`, otherwise
+          it uses the default `expand_kwargs`. When template substitution is used, enum
+          values are converted to their `.value`.
 
         As an example, we have a function with two positional arguments 'a', and 'b' and one keyword
         argument flag:
@@ -265,49 +290,67 @@ class DynamicCommandMixin:
         We have the following template string: `CREATE:FUN:${a} ${b} [${flag}]`.
 
         When we call the function as follows: `func("TEMP", 23)`, we would then expect
-        the returned string to be "CREATE:FUN:TEMP 23 [True]"
+        the returned string to be "CREATE:FUN:TEMP 23 [True]".This function will be called as:
 
-            DynamicCommandMixin.create_command_string(func, template, "TEMP", 23)
+            DynamicCommandMixin.create_command_string(func, provider, "TEMP", 23)
+
+        Note:
+            The processing attributes `__process_kwargs` and `__use_format` are only used when
+            `provider` is a string. The attribute `__process_cmd_string` is used when `provider`
+             is a template/format string or when it's a callable. The `__process_cmd_string` is
+             the last action taken before the result is returned.
 
         Args:
-            func (Callable): a function or method that provides the signature
-            template_str (str): a template for the command
+            func (Callable): a function or method that provides the signature which defines
+                the names available for substitution. The function may also carry processing
+                attributes (`__use_format`, `__process_kwargs`, `__process_cmd_string`).
+            provider (str | Callable): a template/format string or a function that returns a string
             args (tuple): positional arguments that will be used in the command string
             kwargs (dict): keywords arguments that will be used in the command string
-        """
-        try:
-            process_kwargs = getattr(func, "__process_kwargs")
-        except AttributeError:
-            process_kwargs = expand_kwargs
 
-        template = string.Template(template_str)
+        Returns:
+            the final command string ready to be sent to the transport.
 
-        sig = inspect.signature(func)
-        try:
-            bound = sig.bind(*args, **kwargs)
-        except TypeError as exc:
-            raise CommandError(
-                f"Arguments {args}, {kwargs} do not match function signature for {func.__name__}{sig}"
-            ) from exc
-
-        variables = {}
-        for idx, par in enumerate(sig.parameters.values()):
-            # if the argument is of signature '**kwargs' then expand the kwargs
-            if par.kind == inspect.Parameter.VAR_KEYWORD:
-                variables[par.name] = process_kwargs(bound.arguments[par.name])
-                continue
-
-            # otherwise, use the argument value or the default
-            try:
-                variables[par.name] = bound.arguments[par.name]
-            except KeyError:
-                variables[par.name] = par.default
+        Raises:
+            CommandError: if `args`/`kwargs` cannot be bound to `func`'s signature.
+        """
 
-        if hasattr(func, "__use_format"):
-            cmd_string = template_str.format(**variables)
+        if callable(provider):
+            cmd_string = provider(*args, **kwargs)
         else:
-            variables = {k: v.value if isinstance(v, enum.Enum) else v for k, v in variables.items()}
-            cmd_string = template.safe_substitute(variables)
+            try:
+                process_kwargs = getattr(func, "__process_kwargs")
+            except AttributeError:
+                process_kwargs = expand_kwargs
+
+            template = string.Template(template_str := provider)
+
+            sig = inspect.signature(func)
+            try:
+                bound = sig.bind(*args, **kwargs)
+            except TypeError as exc:
+                raise CommandError(
+                    f"Arguments {args}, {kwargs} do not match function signature for {func.__name__}{sig}"
+                ) from exc
+
+            variables = {}
+            for idx, par in enumerate(sig.parameters.values()):
+                # if the argument is of signature '**kwargs' then expand the kwargs
+                if par.kind == inspect.Parameter.VAR_KEYWORD:
+                    variables[par.name] = process_kwargs(bound.arguments[par.name])
+                    continue
+
+                # otherwise, use the argument value or the default
+                try:
+                    variables[par.name] = bound.arguments[par.name]
+                except KeyError:
+                    variables[par.name] = par.default
+
+            if hasattr(func, "__use_format"):
+                cmd_string = template_str.format(**variables)
+            else:
+                variables = {k: v.value if isinstance(v, enum.Enum) else v for k, v in variables.items()}
+                cmd_string = template.safe_substitute(variables)
 
         try:
             process_cmd_string = getattr(func, "__process_cmd_string")
@@ -337,10 +380,14 @@ class DynamicCommandMixin:
         @functools.wraps(attr)
         def command_wrapper(*args, **kwargs):
             """Generates command strings and executes the transport functions."""
-            try:
+
+            if hasattr(attr, "__cmd_string"):
                 cmd_str = getattr(attr, "__cmd_string")
                 cmd_str = self.create_command_string(attr, cmd_str, *args, **kwargs)
-            except AttributeError:
+            elif hasattr(attr, "__cmd_string_func"):
+                func = getattr(attr, "__cmd_string_func")
+                cmd_str = self.create_command_string(attr, func, *args, **kwargs)
+            else:
                 cmd_str = None
 
             response = None

{cgse-0.16.12 → cgse-0.16.14}/libs/cgse-core/tests/test_mixin.py

@@ -201,11 +201,32 @@ def pre_command(transport: DeviceTransport = None, **kwargs):
     LOGGER.info(f"Inside pre_command({transport.__class__.__name__}, {kwargs})")
 
 
-def post_command(transport: DeviceTransport = None, response: bytes = None):
+def post_command(transport: DeviceTransport = None, response: bytes = None) -> bytes:
     LOGGER.info(f"Inside post_command(transport={transport.__class__.__name__}, {response=})")
     return response
 
 
+def rewrite_kwargs(kwargs: dict) -> str:
+    """Rewrite some of the keyword arguments according to device specs."""
+
+    def calc_crc(data) -> int:
+        return len(data)
+
+    # assume we need to build our own fancy device command string...
+    address = kwargs.get("address")
+    identifier = kwargs.get("identifier")
+    cargo1 = kwargs.get("cargo1", 1)
+    cargo2 = kwargs.get("cargo2", 2)
+
+    cmd = f"{address:06X} 0x{identifier:06x} DEV_07463 CARGO1={cargo1:04d} CARGO2={cargo2}"
+
+    return f"{cmd} {calc_crc(cmd)}"
+
+
+def create_fancy_cmd_string(a: str, b: int, *, c: float, d: str) -> str:
+    return f"FANCY {a}, {d} – {b:04d} {c=:.3f}"
+
+
 class NewStyleCommandInterface:
     """Interface definition for new style dynamic commands."""
 
@@ -251,10 +272,26 @@ class NewStyleCommandInterface:
     def test_cmd_enum_with_format(self, enumeration: MyEnum):
         """Returns the command string"""
 
+    @dynamic_command(cmd_type="transaction", cmd_string="ARG_EXPANSION::{mode}::{crc:06x}", use_format=True)
+    def test_cmd_with_arg_expansion(self, *, mode, crc):
+        """Return the command string, after processing the arguments in the overriding function."""
+
     @dynamic_command(cmd_type="transaction", cmd_string="msg = ${msg}", pre_cmd=pre_command, post_cmd=post_command)
-    def test_cmd_pre_post(self, msg: str):
+    def test_cmd_pre_post(self, msg: str) -> bytes:
         """Return the command string, executes pre- and post-commands."""
 
+    @dynamic_command(cmd_type="transaction", cmd_string="TRANS ${a} ${kwargs}")
+    def test_cmd_process_kwargs(self, *, a, **kwargs):
+        """Returns the command string."""
+
+    @dynamic_command(cmd_type="transaction", cmd_string="TRANS ${kwargs}", process_kwargs=rewrite_kwargs)
+    def test_cmd_rewrite_kwargs(self, **kwargs):
+        """Returns the command string with rewritten kwargs."""
+
+    @dynamic_command(cmd_type="transaction", cmd_string_func=create_fancy_cmd_string)
+    def test_cmd_string_func(self, a: str, b: int, *, c: float, d: str) -> bytes:
+        """Returns a command string based on the arguments."""
+
 
 class NewStyleCommand(DynamicCommandMixin, NewStyleCommandInterface):
     """Simple new style commanding interface."""
@@ -263,6 +300,26 @@ class NewStyleCommand(DynamicCommandMixin, NewStyleCommandInterface):
         self.transport = NewStyleTransport()
         super().__init__()
 
+    def test_cmd_with_arg_expansion(self, *, mode, **kwargs):
+        # This function overrides the function from the NewStyleCommandInterface. The reason for doing that is
+        # because we need to reformat and/or process the arguments before passing them to the decorated function.
+
+        # rewrite 'mode'
+        mode = f"{mode:04x}"
+
+        if "crc" in kwargs:
+            crc = kwargs["crc"]
+        else:
+            # 'calculate' the checksum
+            crc = 0x1234
+
+        # pass the method as defined in the NewStyleCommandInterface, to the handle_dynamic_command method of
+        # the mixin class. Provide the expected parameters as if the decorated function would have been called.
+        return DynamicCommandMixin.handle_dynamic_command(self, super().test_cmd_with_arg_expansion)(mode=mode, crc=crc)
+
+        # Note that the following doesn't work, I didn't really figure out why yet...
+        # return super().test_cmd_with_mode_expansion(mode, crc)
+
 
 def test_new_style(caplog):
     caplog.set_level(logging.INFO)
@@ -319,6 +376,19 @@ def test_new_style(caplog):
         in caplog.text
     )
 
+    assert ns.test_cmd_with_arg_expansion(mode=23) == b"ARG_EXPANSION::0017::001234"
+    assert ns.test_cmd_with_arg_expansion(mode=0x10, crc=5678) == b"ARG_EXPANSION::0010::00162e"
+
+    # This tests the expansion of kwargs in the function's signature, by the default `expand_kwargs`
+    assert ns.test_cmd_process_kwargs(a=5, b=2, c=3) == b"TRANS 5 b=2 c=3"
+
+    tcu_mode = 42  # == 0x2A
+    assert ns.test_cmd_rewrite_kwargs(address=5, identifier=2, cargo2=f"{hex(int(tcu_mode))[2:].zfill(4)}") == (
+        b"TRANS 000005 0x000002 DEV_07463 CARGO1=0001 CARGO2=002a 49"
+    )
+
+    assert ns.test_cmd_string_func("Hello!", 5, c=3.14, d="World!").decode() == "FANCY Hello!, World! – 0005 c=3.140"
+
 
 def test_interface_definition():
     with pytest.raises(TypeError):

{cgse-0.16.12 → cgse-0.16.14}/libs/cgse-gui/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-gui"
-version = "0.16.12"
+version = "0.16.14"
 description = "GUI components for CGSE"
 authors = [
     {name = "Rik Huygen", email = "rik.huygen@kuleuven.be"},

{cgse-0.16.12 → cgse-0.16.14}/projects/generic/cgse-tools/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-tools"
-version = "0.16.12"
+version = "0.16.14"
 description = "Tools for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.16.12 → cgse-0.16.14}/projects/generic/keithley-tempcontrol/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "keithley-tempcontrol"
-version = "0.16.12"
+version = "0.16.14"
 description = "Keithley Temperature Control for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.16.12 → cgse-0.16.14}/projects/generic/lakeshore-tempcontrol/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lakeshore-tempcontrol"
-version = "0.16.12"
+version = "0.16.14"
 description = "Lakeshore Temperature Control for CGSE"
 authors = [
     {name = "IVS KU Leuven"}

{cgse-0.16.12 → cgse-0.16.14}/projects/generic/symetrie-hexapod/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "symetrie-hexapod"
-version = "0.16.12"
+version = "0.16.14"
 description = "Symetrie Hexapod implementation for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.16.12 → cgse-0.16.14}/projects/plato/plato-fits/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plato-fits"
-version = "0.16.12"
+version = "0.16.14"
 description = "FITS Persistence implementation for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.16.12 → cgse-0.16.14}/projects/plato/plato-hdf5/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plato-hdf5"
-version = "0.16.12"
+version = "0.16.14"
 description = "HDF5 Persistence sub-class for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.16.12 → cgse-0.16.14}/projects/plato/plato-spw/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plato-spw"
-version = "0.16.12"
+version = "0.16.14"
 description = "SpaceWire implementation for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.16.12 → cgse-0.16.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse"
-version = "0.16.12"
+version = "0.16.14"
 description = "Generic Common-EGSE: Commanding and monitoring lab equipment"
 authors = [
     {name = "IvS KU Leuven"}