cgse 0.16.13__tar.gz → 0.16.14__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgse
-Version: 0.16.13
+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.13 → cgse-0.16.14}/libs/cgse-common/pyproject.toml

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

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

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

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

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

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

@@ -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.13 → cgse-0.16.14}/libs/cgse-core/tests/test_mixin.py

@@ -205,6 +205,7 @@ def post_command(transport: DeviceTransport = None, response: bytes = None) -> b
     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."""
 
@@ -222,6 +223,10 @@ def rewrite_kwargs(kwargs: dict) -> str:
     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."""
 
@@ -267,11 +272,7 @@ 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
-    )
+    @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."""
 
@@ -287,6 +288,11 @@ class NewStyleCommandInterface:
     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."""
 
@@ -302,23 +308,19 @@ class NewStyleCommand(DynamicCommandMixin, NewStyleCommandInterface):
         mode = f"{mode:04x}"
 
         if "crc" in kwargs:
-            crc = kwargs['crc']
+            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
-        )
+        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)
 
@@ -380,11 +382,14 @@ def test_new_style(caplog):
     # 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
+    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.13 → cgse-0.16.14}/libs/cgse-gui/pyproject.toml

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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