cgse 0.17.0__tar.gz → 0.17.1__tar.gz

{cgse-0.17.0 → cgse-0.17.1}/CHANGELOG.md

@@ -6,25 +6,41 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 
-## [Unreleased](https://github.com/IvS-KULeuven/cgse/compare/v0.17.0...HEAD)
+## [Unreleased](https://github.com/IvS-KULeuven/cgse/compare/v0.17.1...HEAD)
 
+### Fixed
+- ...
 ### Added
 - ...
 
-## [v0.17.0](https://github.com/IvS-KULeuven/cgse/compare/v0.16.14...v0.17.0)
+## [v0.17.1](https://github.com/IvS-KULeuven/cgse/compare/v0.17.0...v0.17.1) – 20/11/2025
+
+### Fixed
+- Fixed a missing expanduser(). Apparently a `pathresolve()` doesn't handle the '`~`' character.
+- Fixed `env_var()` which is a context manager for temporarily setting an environment variable. It uses `setup_env()` 
+  to update the environment before and after the `yield`, but `setup_env()` only initializes once.
+- Fixed unit tests for settings, setup, and env.
+
+### Changed
+- Some of the debug messages in settings are now filtered behind the VERBOSE_DEBUG flag.
+
+## [v0.17.0](https://github.com/IvS-KULeuven/cgse/compare/v0.16.14...v0.17.0) – 20/11/2025
 
 ### Added
-- Added this CHANGELOG file.
-- Added an initial implementation of the ARIEL Telescope Control Unit (TCU). This is a separate package in this monorepo that is located at `projects/ariel/ariel-tcu`. The package will be added to PyPI as `ariel-tcu`.
-- Added a `read_string()` method to the `DeviceTransport` and `AsyncDeviceTransport` classes.
+- Added this CHANGELOG file. [#209](https://github.com/IvS-KULeuven/cgse/pull/209)
+- Added an initial implementation of the ARIEL Telescope Control Unit (TCU). This is a separate package in this 
+  monorepo that is located at `projects/ariel/ariel-tcu`. The package will be added to PyPI as `ariel-tcu`. [#178](https://github.com/IvS-KULeuven/cgse/pull/178)
+- Added a `read_string()` method to the `DeviceTransport` and `AsyncDeviceTransport` classes. [#209](https://github.com/IvS-KULeuven/cgse/pull/209)
 ### Fixed
-- Fixed the `sm_cs` for the missing `--full` cli argument.
-- Fixed the configuration of the InfluxDB client. The client can now be fully configured with environment variables if needed.
+- Fixed the `sm_cs` for the missing `--full` cli argument. [#204](https://github.com/IvS-KULeuven/cgse/pull/204)
+- Fixed the configuration of the InfluxDB client. The client can now be fully configured with environment variables 
+  if needed. [#206](https://github.com/IvS-KULeuven/cgse/pull/206)
 ### Changed
-- Improved initialization of the process environment with `setup_env()`.
-- The configuration manager now also re-registers the obsid table to the storage.
-- The `cgse` subcommand to start the notification hub is changed from `not` to `nh`. Use `cgse nh [start|stop|status]`.
-- The environment variables that contain a path can start with a tilde '`~`' which will be expanded to the user's home directory when used.
+- Improved initialization of the process environment with `setup_env()`. [#208](https://github.com/IvS-KULeuven/cgse/pull/208)
+- The configuration manager now also re-registers the obsid table to the storage. [#207](https://github.com/IvS-KULeuven/cgse/pull/207)
+- The `cgse` subcommand to start the notification hub is changed from `not` to `nh`. Use `cgse nh [start|stop|status]`.  [#209](https://github.com/IvS-KULeuven/cgse/pull/209)
+- The environment variables that contain a path can start with a tilde '`~`' which will be expanded to the user's 
+  home directory when used. [#204](https://github.com/IvS-KULeuven/cgse/pull/204)
 ### Docs
 - Documentation updates for the Python version, the CLI `cgse` subcommands,  environment and the introduction of `dotenv`, ...
 - Updated information on the use of `dotenv` in the developer guid.

{cgse-0.17.0 → cgse-0.17.1}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-common"
-version = "0.17.0"
+version = "0.17.1"
 description = "Software framework to support hardware testing"
 authors = [
     {name = "IvS KU Leuven"}
@@ -64,6 +64,9 @@ log_cli_level = "DEBUG"
 filterwarnings = [
     "ignore::DeprecationWarning"
 ]
+markers = [
+    "slow: marks tests as slow (deselect with '-m \"not slow\"')"
+]
 
 [tool.coverage.run]
 omit = [

{cgse-0.17.0 → cgse-0.17.1}/libs/cgse-common/src/egse/config.py

@@ -154,13 +154,14 @@ def find_files(pattern: str, root: Path | str, in_dir: str = None) -> Generator[
     Returns:
         Paths of files matching pattern, from root.
     """
-    root = Path(root).resolve()
+    root = Path(root).expanduser().resolve()
     if not root.is_dir():
         root = root.parent
     if not root.exists():
         raise ValueError(f"The root argument didn't resolve into a valid directory: {root}.")
 
-    exclude_dirs = ("venv", "venv38", ".venv", ".nox", ".git", ".idea", ".DS_Store")
+    # FIXME: at some point we might want to make this configurable, through env?
+    exclude_dirs = ("venv", "venv38", ".venv", ".nox", ".git", ".idea", ".DS_Store", "__pycache__")
 
     for path, folders, files in os.walk(root):
         folders[:] = list(filter(lambda x: x not in exclude_dirs, folders))

{cgse-0.17.0 → cgse-0.17.1}/libs/cgse-common/src/egse/env.py

@@ -678,6 +678,7 @@ def env_var(**kwargs: str | int | float | bool | None):
         else:
             os.environ[k] = v
 
+    setup_env.is_initialized = False
     setup_env()
 
     yield
@@ -689,6 +690,7 @@ def env_var(**kwargs: str | int | float | bool | None):
         else:
             os.environ[k] = v
 
+    setup_env.is_initialized = False
     setup_env()
 
 

{cgse-0.17.0 → cgse-0.17.1}/libs/cgse-common/src/egse/scpi.py

@@ -15,6 +15,9 @@ DEFAULT_READ_TIMEOUT = 1.0  # seconds
 DEFAULT_CONNECT_TIMEOUT = 3.0  # seconds
 IDENTIFICATION_QUERY = "*IDN?"
 
+SEPARATOR = b"\n"
+SEPARATOR_STR = SEPARATOR.decode()
+
 
 class SCPICommand:
     """Base class for SCPI commands."""
@@ -57,7 +60,8 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
             id_validation: String that should appear in the device's identification response
         """
         super().__init__()
-        self.device_name = device_name
+
+        self._device_name = device_name
         self.hostname = hostname
         self.port = port
         self.settings = settings or {}
@@ -77,6 +81,10 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
     def is_simulator(self) -> bool:
         return False
 
+    @property
+    def device_name(self) -> str:
+        return self._device_name
+
     async def initialize(self, commands: list[tuple[str, bool]] = None, reset_device: bool = False) -> list[str | None]:
         """Initialize the device with optional reset and command sequence.
 
@@ -113,7 +121,7 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
         responses = []
 
         if reset_device:
-            logger.info(f"Resetting the {self.device_name}...")
+            logger.info(f"Resetting the {self._device_name}...")
             await self.write("*RST")  # this also resets the user-defined buffer
 
         for cmd, expects_response in commands:
@@ -140,47 +148,47 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
         async with self._connect_lock:
             # Sanity checks
             if self._is_connection_open:
-                logger.warning(f"{self.device_name}: Trying to connect to an already connected device.")
+                logger.warning(f"{self._device_name}: Trying to connect to an already connected device.")
                 return
 
             if not self.hostname:
-                raise ValueError(f"{self.device_name}: Hostname is not initialized.")
+                raise ValueError(f"{self._device_name}: Hostname is not initialized.")
 
             if not self.port:
-                raise ValueError(f"{self.device_name}: Port number is not initialized.")
+                raise ValueError(f"{self._device_name}: Port number is not initialized.")
 
             # Attempt to establish a connection
             try:
-                logger.debug(f'Connecting to {self.device_name} at "{self.hostname}" using port {self.port}')
+                logger.debug(f'Connecting to {self._device_name} at "{self.hostname}" using port {self.port}')
 
                 connect_task = asyncio.open_connection(self.hostname, self.port)
                 self._reader, self._writer = await asyncio.wait_for(connect_task, timeout=self.connect_timeout)
 
                 self._is_connection_open = True
 
-                logger.debug(f"Successfully connected to {self.device_name}.")
+                logger.debug(f"Successfully connected to {self._device_name}.")
 
             except asyncio.TimeoutError as exc:
                 raise DeviceTimeoutError(
-                    self.device_name, f"Connection to {self.hostname}:{self.port} timed out"
+                    self._device_name, f"Connection to {self.hostname}:{self.port} timed out"
                 ) from exc
             except ConnectionRefusedError as exc:
                 raise DeviceConnectionError(
-                    self.device_name, f"Connection refused to {self.hostname}:{self.port}"
+                    self._device_name, f"Connection refused to {self.hostname}:{self.port}"
                 ) from exc
             except socket.gaierror as exc:
-                raise DeviceConnectionError(self.device_name, f"Address resolution error for {self.hostname}") from exc
+                raise DeviceConnectionError(self._device_name, f"Address resolution error for {self.hostname}") from exc
             except socket.herror as exc:
-                raise DeviceConnectionError(self.device_name, f"Host address error for {self.hostname}") from exc
+                raise DeviceConnectionError(self._device_name, f"Host address error for {self.hostname}") from exc
             except OSError as exc:
-                raise DeviceConnectionError(self.device_name, f"OS error: {exc}") from exc
+                raise DeviceConnectionError(self._device_name, f"OS error: {exc}") from exc
 
             # Validate device identity if requested
             if self.id_validation:
                 logger.debug("Validating connection..")
                 if not await self.is_connected():
                     await self.disconnect()
-                    raise DeviceConnectionError(self.device_name, "Device connected but failed identity verification")
+                    raise DeviceConnectionError(self._device_name, "Device connected but failed identity verification")
 
     async def disconnect(self) -> None:
         """Disconnect from the device asynchronously.
@@ -191,14 +199,14 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
         async with self._connect_lock:
             try:
                 if self._is_connection_open and self._writer is not None:
-                    logger.debug(f"Disconnecting from {self.device_name} at {self.hostname}")
+                    logger.debug(f"Disconnecting from {self._device_name} at {self.hostname}")
                     self._writer.close()
                     await self._writer.wait_closed()
                     self._writer = None
                     self._reader = None
                     self._is_connection_open = False
             except Exception as exc:
-                raise DeviceConnectionError(self.device_name, f"Could not close connection: {exc}") from exc
+                raise DeviceConnectionError(self._device_name, f"Could not close connection: {exc}") from exc
 
     async def reconnect(self) -> None:
         """Reconnect to the device asynchronously."""
@@ -222,7 +230,7 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
             # Validate the response if validation string is provided
             if self.id_validation and self.id_validation not in id_response:
                 logger.error(
-                    f"{self.device_name}: Device did not respond correctly to identification query. "
+                    f"{self._device_name}: Device did not respond correctly to identification query. "
                     f'Expected "{self.id_validation}" in response, got: {id_response}'
                 )
                 await self.disconnect()
@@ -231,7 +239,7 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
             return True
 
         except DeviceError as exc:
-            logger.error(f"{self.device_name}: Connection test failed: {exc}", exc_info=True)
+            logger.error(f"{self._device_name}: Connection test failed: {exc}", exc_info=True)
             await self.disconnect()
             return False
 
@@ -248,20 +256,20 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
         async with self._io_lock:
             try:
                 if not self._is_connection_open or self._writer is None:
-                    raise DeviceConnectionError(self.device_name, "Device not connected, use connect() first")
+                    raise DeviceConnectionError(self._device_name, "Device not connected, use connect() first")
 
-                # Ensure command ends with newline
-                if not command.endswith("\n"):
-                    command += "\n"
+                # Ensure command ends with the proper separator or terminator
+                if not command.endswith(SEPARATOR_STR):
+                    command += SEPARATOR_STR
 
                 logger.info(f"-----> {command}")
                 self._writer.write(command.encode())
                 await self._writer.drain()
 
             except asyncio.TimeoutError as exc:
-                raise DeviceTimeoutError(self.device_name, "Write operation timed out") from exc
+                raise DeviceTimeoutError(self._device_name, "Write operation timed out") from exc
             except (ConnectionError, OSError) as exc:
-                raise DeviceConnectionError(self.device_name, f"Communication error: {exc}") from exc
+                raise DeviceConnectionError(self._device_name, f"Communication error: {exc}") from exc
 
     async def read(self) -> bytes:
         """
@@ -276,7 +284,7 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
         """
         async with self._io_lock:
             if not self._is_connection_open or self._reader is None:
-                raise DeviceConnectionError(self.device_name, "Device not connected, use connect() first")
+                raise DeviceConnectionError(self._device_name, "Device not connected, use connect() first")
 
             try:
                 # First, small delay to allow device to prepare response
@@ -285,19 +293,19 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
                 # Try to read until newline (common SCPI terminator)
                 try:
                     response = await asyncio.wait_for(
-                        self._reader.readuntil(separator=b"\n"), timeout=self.read_timeout
+                        self._reader.readuntil(separator=SEPARATOR), timeout=self.read_timeout
                     )
                     logger.info(f"<----- {response}")
                     return response
 
                 except asyncio.IncompleteReadError as exc:
                     # Connection closed before receiving full response
-                    logger.warning(f"{self.device_name}: Incomplete read, got {len(exc.partial)} bytes")
-                    return exc.partial if exc.partial else b"\r\n"
+                    logger.warning(f"{self._device_name}: Incomplete read, got {len(exc.partial)} bytes")
+                    return exc.partial if exc.partial else SEPARATOR
 
                 except asyncio.LimitOverrunError:
                     # Response too large for buffer
-                    logger.warning(f"{self.device_name}: Response exceeded buffer limits")
+                    logger.warning(f"{self._device_name}: Response exceeded buffer limits")
                     # Fall back to reading a large chunk
                     return await asyncio.wait_for(
                         self._reader.read(8192),  # Larger buffer for exceptional cases
@@ -305,9 +313,9 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
                     )
 
             except asyncio.TimeoutError as exc:
-                raise DeviceTimeoutError(self.device_name, "Read operation timed out") from exc
+                raise DeviceTimeoutError(self._device_name, "Read operation timed out") from exc
             except Exception as exc:
-                raise DeviceConnectionError(self.device_name, f"Read error: {exc}") from exc
+                raise DeviceConnectionError(self._device_name, f"Read error: {exc}") from exc
 
     async def trans(self, command: str) -> bytes:
         """
@@ -328,11 +336,11 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
         async with self._io_lock:
             try:
                 if not self._is_connection_open or self._writer is None:
-                    raise DeviceConnectionError(self.device_name, "Device not connected, use connect() first")
+                    raise DeviceConnectionError(self._device_name, "Device not connected, use connect() first")
 
                 # Ensure command ends with newline
-                if not command.endswith("\n"):
-                    command += "\n"
+                if not command.endswith(SEPARATOR_STR):
+                    command += SEPARATOR_STR
 
                 logger.info(f"-----> {command}")
                 self._writer.write(command.encode())
@@ -344,19 +352,19 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
                 # Try to read until newline (common SCPI terminator)
                 try:
                     response = await asyncio.wait_for(
-                        self._reader.readuntil(separator=b"\n"), timeout=self.read_timeout
+                        self._reader.readuntil(separator=SEPARATOR), timeout=self.read_timeout
                     )
                     logger.info(f"<----- {response}")
                     return response
 
                 except asyncio.IncompleteReadError as exc:
                     # Connection closed before receiving full response
-                    logger.warning(f"{self.device_name}: Incomplete read, got {len(exc.partial)} bytes")
-                    return exc.partial if exc.partial else b"\r\n"
+                    logger.warning(f"{self._device_name}: Incomplete read, got {len(exc.partial)} bytes")
+                    return exc.partial if exc.partial else SEPARATOR
 
                 except asyncio.LimitOverrunError:
                     # Response too large for buffer
-                    logger.warning(f"{self.device_name}: Response exceeded buffer limits")
+                    logger.warning(f"{self._device_name}: Response exceeded buffer limits")
                     # Fall back to reading a large chunk
                     return await asyncio.wait_for(
                         self._reader.read(8192),  # Larger buffer for exceptional cases
@@ -364,11 +372,11 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
                     )
 
             except asyncio.TimeoutError as exc:
-                raise DeviceTimeoutError(self.device_name, "Communication timed out") from exc
+                raise DeviceTimeoutError(self._device_name, "Communication timed out") from exc
             except (ConnectionError, OSError) as exc:
-                raise DeviceConnectionError(self.device_name, f"Communication error: {exc}") from exc
+                raise DeviceConnectionError(self._device_name, f"Communication error: {exc}") from exc
             except Exception as exc:
-                raise DeviceConnectionError(self.device_name, f"Transaction error: {exc}") from exc
+                raise DeviceConnectionError(self._device_name, f"Transaction error: {exc}") from exc
 
     async def __aenter__(self):
         """Async context manager entry."""

{cgse-0.17.0 → cgse-0.17.1}/libs/cgse-common/src/egse/settings.py

@@ -72,13 +72,14 @@ from typing import Any
 
 import yaml  # This module is provided by the pip package PyYaml - pip install pyyaml
 
+from egse.env import bool_env
 from egse.env import get_local_settings_env_name
 from egse.env import get_local_settings_path
 from egse.log import logger
 from egse.system import attrdict
 from egse.system import recursive_dict_update
 
-_HERE = Path(__file__).resolve().parent
+VERBOSE_DEBUG = bool_env("VERBOSE_DEBUG")
 
 
 class SettingsError(Exception):
@@ -192,6 +193,9 @@ def load_local_settings(force: bool = False) -> attrdict:
     local_settings = attrdict()
 
     local_settings_path = get_local_settings_path()
+    if VERBOSE_DEBUG:
+        logger.debug(f"{get_local_settings_env_name()=}")
+        logger.debug(f"{local_settings_path=}")
 
     if local_settings_path:
         path = Path(local_settings_path).expanduser()
@@ -218,7 +222,8 @@ def read_configuration_file(filename: Path, *, force=False) -> dict:
     filename = str(filename)
 
     if force or not Settings.is_memoized(filename):
-        logger.debug(f"Parsing YAML configuration file {filename}.")
+        if VERBOSE_DEBUG:
+            logger.debug(f"Parsing YAML configuration file {filename}.")
 
         with open(filename, "r") as stream:
             try:

{cgse-0.17.0 → cgse-0.17.1}/libs/cgse-common/src/egse/socketdevice.py

@@ -8,6 +8,8 @@ import socket
 import time
 from typing import Optional
 
+from egse.device import AsyncDeviceInterface
+from egse.device import AsyncDeviceTransport
 from egse.device import DeviceConnectionError
 from egse.device import DeviceConnectionInterface
 from egse.device import DeviceTimeoutError
@@ -252,7 +254,7 @@ class SocketDevice(DeviceConnectionInterface, DeviceTransport):
             raise DeviceConnectionError(self.device_name, "Socket communication error.") from exc
 
 
-class AsyncSocketDevice(DeviceConnectionInterface, DeviceTransport):
+class AsyncSocketDevice(AsyncDeviceInterface, AsyncDeviceTransport):
     """
     Async socket-backed device using asyncio streams.
 

{cgse-0.17.0 → cgse-0.17.1}/libs/cgse-common/tests/test_settings.py

@@ -78,15 +78,17 @@ def test_load_local_settings():
 
 
 def test_load_new_local_settings():
-    with env_var(CGSE_LOCAL_SETTINGS=str(HERE / "data" / "data" / "new_local_settings.yaml")):
+    print()
+
+    with env_var(PROJECT="CGSE"), env_var(CGSE_LOCAL_SETTINGS=str(HERE / "data" / "data" / "new_local_settings.yaml")):
         settings = Settings.load(add_local_settings=False)
-        rich.print(settings)
+        # rich.print(settings)
 
         with pytest.raises(AttributeError):
             assert settings.NEW_GROUP["ID"] == "the ID of the new group"
 
-        settings = Settings.load(add_local_settings=True)
-        rich.print(settings)
+        settings = Settings.load(add_local_settings=True, force=True)
+        # rich.print(settings)
 
         # This should have been added, we can add new main groups
 
@@ -136,3 +138,7 @@ def test_profiling(capsys):
     assert "PACKAGES" in x
 
     Settings.set_profiling(False)
+
+
+if __name__ == "__main__":
+    test_load_new_local_settings()

{cgse-0.17.0 → cgse-0.17.1}/libs/cgse-common/tests/test_setup.py

@@ -18,7 +18,7 @@ from egse.env import get_conf_data_location
 from egse.env import get_conf_data_location_env_name
 from egse.env import get_conf_repo_location_env_name
 from egse.env import print_env
-from egse.env import initialize as initialize_env
+from egse.env import setup_env
 from egse.env import set_conf_repo_location
 from egse.setup import Setup
 from egse.setup import get_last_setup_id_file_path
@@ -578,7 +578,7 @@ def test_lazy_load_value_from_yaml(default_test_setup):
       file identifier.
     """
 
-    initialize_env()
+    setup_env()
     print_env()
 
     Setup.from_yaml_file.cache_clear()  # needed because the same file is used elsewhere
@@ -591,7 +591,7 @@ def test_lazy_load_value_from_yaml(default_test_setup):
 
     arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
 
-    new_csv_file_name = Path(get_conf_data_location()) / "data/test_arr.csv"
+    new_csv_file_name = Path(get_conf_data_location()).expanduser() / "data/test_arr.csv"
     np.savetxt(new_csv_file_name, arr, delimiter=",", header="Test data used in test_setup.py")
 
     # Test the values from the original array

{cgse-0.17.0 → cgse-0.17.1}/libs/cgse-common/tests/test_socketdevice.py

@@ -1,7 +1,6 @@
 # Unit Tests were created by GitHub Copilot and adapted/improved afterward.
 
 import asyncio
-import socket
 import socketserver
 import threading
 import time
@@ -19,6 +18,7 @@ from egse.system import type_name
 logger = logging.getLogger("egse.test.socketdevice")
 
 SEPARATOR = b"\x03"
+SEPARATOR_STR = SEPARATOR.decode()
 
 
 # Synchronous server used by SocketDevice tests

{cgse-0.17.0 → cgse-0.17.1}/libs/cgse-common/tests/test_system.py

@@ -12,6 +12,7 @@ import time
 from pathlib import Path
 
 import pytest
+import rich
 from pytest import approx
 
 from egse.decorators import execution_count
@@ -47,6 +48,7 @@ from egse.system import is_not_in
 from egse.system import ping
 from egse.system import read_last_line
 from egse.system import read_last_lines
+from egse.system import recursive_dict_update
 from egse.system import replace_environment_variable
 from egse.system import save_average_execution_time
 from egse.system import touch
@@ -906,7 +908,6 @@ def test_touch():
 
 
 def test_is_module():
-    import egse
     import egse.version
     from egse.system import get_os_name
 
@@ -921,7 +922,6 @@ def test_is_module():
 
 
 def test_is_namespace():
-    import egse
     import egse.version
     from egse.system import get_os_name
 
@@ -1107,3 +1107,32 @@ def test_camel_to_snake():
     assert camel_to_snake("My123BestProject") == "my123_best_project"
 
     assert camel_to_snake("is_already_snake") == "is_already_snake"
+
+
+def test_recursive_dict_update():
+    print()
+
+    top = {"GROUP": {"G1": "initial top-level group"}}
+    x = {"NEW_GROUP": {"G2": "additional top-level group"}}
+
+    recursive_dict_update(top, x)
+
+    assert "NEW_GROUP" in top
+    assert "initial" in top["GROUP"]["G1"]
+    assert "additional" in top["NEW_GROUP"]["G2"]
+
+    x = {"NEW_SUBGROUP": "a new subgroup added to NEW_GROUP"}
+
+    recursive_dict_update(top["NEW_GROUP"], x)
+
+    rich.print(top)
+
+    assert "NEW_SUBGROUP" in top["NEW_GROUP"]
+
+    x = {"GROUP": {"G3": "a new group added to top-level GROUP"}}
+
+    recursive_dict_update(top, x)
+
+    rich.print(top)
+
+    assert "G3" in top["GROUP"]

{cgse-0.17.0 → cgse-0.17.1}/libs/cgse-coordinates/pyproject.toml

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

{cgse-0.17.0 → cgse-0.17.1}/libs/cgse-core/pyproject.toml

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

{cgse-0.17.0 → cgse-0.17.1}/libs/cgse-gui/pyproject.toml

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

{cgse-0.17.0 → cgse-0.17.1}/make-a-release.md

@@ -3,9 +3,14 @@
 
 ## Making a release
 
+- run `uvx ruff format`
+- commit all changes with a proper message
 - add all notable changes to the CHANGELOG file
+  - fix the links in the headers if needed
+  - add links to the different pull requests
+  - commit the CHANGELOG file
 - bump the version number: `uv run bump.py [patch|minor|major]`
-- commit all changes with a proper message
+- commit all `pyproject.toml` files after the version bump
 - push the changes to the dedicated branch (I use PyCharm for this)
 - remove the old distributions: `rm -r dist`
 - build the packages: `uv build --all-packages`

{cgse-0.17.0 → cgse-0.17.1}/projects/ariel/ariel-tcu/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ariel-tcu"
-version = "0.17.0"
+version = "0.17.1"
 description = "Telescope Control Unit (TCU) for Ariel"
 authors = [
     {name = "IVS KU Leuven"}

{cgse-0.17.0 → cgse-0.17.1}/projects/generic/cgse-tools/pyproject.toml

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

{cgse-0.17.0 → cgse-0.17.1}/projects/generic/cgse-tools/src/cgse_tools/cgse_commands.py

@@ -217,6 +217,7 @@ def show_setup(
     list_all: Annotated[bool, typer.Option(help="Print a list of all available setups")] = False,
     setup_id: Annotated[int, typer.Option(help="Show the setup with this id")] = -1,
 ):
+    """Show the Setup that was selected from the options."""
     if use_cm:
         try:
             from egse.confman import ConfigurationManagerProxy

{cgse-0.17.0 → cgse-0.17.1}/projects/generic/keithley-tempcontrol/pyproject.toml

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