cgse-common 0.17.0__tar.gz → 0.17.2__tar.gz

{cgse_common-0.17.0 → cgse_common-0.17.2}/.gitignore

@@ -32,6 +32,11 @@ venv
 
 .idea
 
+# VSCode IDE
+
+.vscode
+*.code-workspace
+
 # MKDOCS documentation site
 
 /site

{cgse_common-0.17.0 → cgse_common-0.17.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgse-common
-Version: 0.17.0
+Version: 0.17.2
 Summary: Software framework to support hardware testing
 Author: IvS KU Leuven
 Maintainer-email: Rik Huygen <rik.huygen@kuleuven.be>, Sara Regibo <sara.regibo@kuleuven.be>

{cgse_common-0.17.0 → cgse_common-0.17.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-common"
-version = "0.17.0"
+version = "0.17.2"
 description = "Software framework to support hardware testing"
 authors = [
     {name = "IvS KU Leuven"}
@@ -64,20 +64,27 @@ log_cli_level = "DEBUG"
 filterwarnings = [
     "ignore::DeprecationWarning"
 ]
+markers = [
+    "slow: marks tests as slow (deselect with '-m \"not slow\"')"
+]
 
+# Some of these omitted files are only temporary omitted until refactored
 [tool.coverage.run]
 omit = [
     "tests/*",
     "conftest.py",
+    "src/egse/ratelimit.py",
+    "src/egse/plugins/metrics/duckdb.py",
+    "src/egse/plugins/metrics/timescaledb.py",
 ]
 
 [tool.hatch.build.targets.sdist]
 exclude = [
-    "/tests",
-    "/pytest.ini",
-    "/.gitignore",
-    "/*poetry*",
-    "/*setuptools*",
+    "tests",
+    "pytest.ini",
+    ".gitignore",
+    "*poetry*",
+    "*setuptools*",
 ]
 
 [tool.hatch.build.targets.wheel]
@@ -87,8 +94,12 @@ packages = ["src/egse", "src/scripts", "src/cgse_common"]
 line-length = 120
 
 [tool.ruff.lint]
+select = ["F", "I"]
 extend-select = ["E", "W"]
 
+[tool.ruff.lint.isort]
+force-single-line = true
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

{cgse_common-0.17.0 → cgse_common-0.17.2}/src/egse/bits.py

@@ -5,7 +5,6 @@ This module contains a number of convenience functions to work with bits, bytes
 from __future__ import annotations
 
 import ctypes
-from collections.abc import Iterable
 from typing import Union
 
 
@@ -33,7 +32,7 @@ def extract_bits(value: int, start_position: int, num_bits: int) -> int:
     return extracted_bits
 
 
-def set_bit(value: int, bit) -> int:
+def set_bit(value: int, bit: int) -> int:
     """
     Set bit to 1 for the given value.
 
@@ -47,7 +46,7 @@ def set_bit(value: int, bit) -> int:
     return value | (1 << bit)
 
 
-def set_bits(value: int, bits: tuple) -> int:
+def set_bits(value: int, bits: tuple[int, int]) -> int:
     """
     Set the given bits in value to 1.
 
@@ -63,7 +62,7 @@ def set_bits(value: int, bits: tuple) -> int:
     return value
 
 
-def clear_bit(value: int, bit) -> int:
+def clear_bit(value: int, bit: int) -> int:
     """
     Set bit to 0 for the given value.
 
@@ -77,7 +76,7 @@ def clear_bit(value: int, bit) -> int:
     return value & ~(1 << bit)
 
 
-def clear_bits(value: int, bits: tuple) -> int:
+def clear_bits(value: int, bits: tuple[int, int]) -> int:
     """
     Set the given bits in value to 0.
 
@@ -93,7 +92,7 @@ def clear_bits(value: int, bits: tuple) -> int:
     return value
 
 
-def toggle_bit(value: int, bit) -> int:
+def toggle_bit(value: int, bit: int) -> int:
     """
     Toggle the bit in the given value.
 
@@ -107,7 +106,7 @@ def toggle_bit(value: int, bit) -> int:
     return value ^ (1 << bit)
 
 
-def bit_set(value: int, bit) -> bool:
+def bit_set(value: int, bit: int) -> bool:
     """
     Return True if the bit is set.
 
@@ -122,27 +121,25 @@ def bit_set(value: int, bit) -> bool:
     return value & bit_value == bit_value
 
 
-def bits_set(value: int, *args: Union[int, Iterable[int]]) -> bool:
+def bits_set(value: int, *args: int) -> bool:
     """
     Return True if all the bits are set.
 
     Args:
         value (int): the value to check
         args: a set of indices of the bits to check, starting from 0 at the LSB.
-            All the indices can be given as separate arguments, or they can be passed
-            in as a list.
+            All the indices shall be given as separate arguments, i.e. unpack a list
+            if needed.
 
     Returns:
         True if all the bits are set (1).
 
     Examples:
-        >>> assert bits_set(0b0101_0000_1011, [0, 1, 3, 8, 10])
-        >>> assert bits_set(0b0101_0000_1011, [3, 8])
-        >>> assert not bits_set(0b0101_0000_1011, [1, 2, 3])
+        >>> assert bits_set(0b0101_0000_1011, 0, 1, 3, 8, 10)
+        >>> assert bits_set(0b0101_0000_1011, 3, 8)
+        >>> assert not bits_set(0b0101_0000_1011, *[1, 2, 3])
     """
 
-    if len(args) == 1 and isinstance(args[0], list):
-        args = args[0]
     return all([bit_set(value, bit) for bit in args])
 
 
@@ -506,7 +503,7 @@ def crc_calc(data: list[bytes | int], start: int, len_: int) -> int:
     Reference:
         The description of the CRC calculation for RMAP is given in the ECSS document
         _Space Engineering: SpaceWire - Remote Memory Access Protocol_, section A.3
-        on page 80 [ECSS‐E‐ST‐50‐52C].
+        on page 80 [ECSS-E-ST-50-52C].
 
     """
     crc: int = 0
@@ -548,7 +545,7 @@ def s16(value: int) -> int:
         >>> s16(0b1000_0000_0001_0001)
         -32751
 
-        The 'bin()' fuction will return a strange representation of this number:
+        The 'bin()' function will return a strange representation of this number:
 
         >>> bin(-32751)
         '-0b111111111101111'

{cgse_common-0.17.0 → cgse_common-0.17.2}/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_common-0.17.0 → cgse_common-0.17.2}/src/egse/decorators.py

@@ -15,8 +15,8 @@ from typing import Optional
 
 import rich
 
-from egse.system import get_caller_info
 from egse.log import logger
+from egse.system import get_caller_info
 
 
 def static_vars(**kwargs):
@@ -316,7 +316,10 @@ def debug(func):
 
 
 def profile_func(
-    output_file: str = None, sort_by: str = "cumulative", lines_to_print: int = None, strip_dirs: bool = False
+    output_file: str | None = None,
+    sort_by: str = "cumulative",
+    lines_to_print: int | None = None,
+    strip_dirs: bool = False,
 ) -> Callable:
     """A time profiler decorator.
 
@@ -346,7 +349,7 @@ def profile_func(
         decorator](https://gist.github.com/ekhoda/2de44cf60d29ce24ad29758ce8635b78).
 
         Inspired by and modified the profile decorator of Giampaolo Rodola:
-        [profile decorato](http://code.activestate.com/recipes/577817-profile-decorator/).
+        [profile decorator](http://code.activestate.com/recipes/577817-profile-decorator/).
 
 
     """

{cgse_common-0.17.0 → cgse_common-0.17.2}/src/egse/env.py

@@ -72,8 +72,8 @@ import os
 import warnings
 from pathlib import Path
 
-from dotenv import load_dotenv as _load_dotenv
 from dotenv import find_dotenv
+from dotenv import load_dotenv as _load_dotenv
 from rich.console import Console
 
 from egse.decorators import static_vars
@@ -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,12 +690,14 @@ def env_var(**kwargs: str | int | float | bool | None):
         else:
             os.environ[k] = v
 
+    setup_env.is_initialized = False
     setup_env()
 
 
 def main(args: list | None = None):  # pragma: no cover
     import argparse
     import sys
+
     import rich
 
     parser = argparse.ArgumentParser()

{cgse_common-0.17.0 → cgse_common-0.17.2}/src/egse/exceptions.py

@@ -61,3 +61,6 @@ class Abort(RuntimeError):
 
 class InitialisationError(Error):
     """Raised when an initialisation failed."""
+
+
+InitializationError = InitialisationError  # Alias with American spelling

{cgse_common-0.17.0 → cgse_common-0.17.2}/src/egse/log.py

@@ -18,6 +18,7 @@ __all__ = [
     "LOG_DATE_FORMAT_FULL",
     "LOG_DATE_FORMAT_CLEAN",
     "logger",
+    "logging",  # export to guarantee that this module is imported and initialized before users use logging
     "root_logger",
     "egse_logger",
     "get_log_level_from_env",
@@ -84,7 +85,7 @@ class NonEGSEFilter(logging.Filter):
         return not record.name.startswith("egse")
 
 
-def get_log_level_from_env(env_var: str = "LOG_LEVEL", default: int = logging.INFO):
+def get_log_level_from_env(env_var: str = "LOG_LEVEL", default: str = "INFO") -> int:
     """Read the log level from an environment variable."""
     log_level_str = os.getenv(env_var, default)
 
@@ -95,18 +96,16 @@ def get_log_level_from_env(env_var: str = "LOG_LEVEL", default: int = logging.IN
         if 10 <= log_level <= 50:
             return log_level
         else:
-            logging.warning(
-                f"Log level {log_level} outside standard range (10-50). Using {logging.getLevelName(default)}."
-            )
-            return default
+            logging.warning(f"Log level {log_level} outside standard range (10-50). Using {default.upper()}.")
+            return logging._nameToLevel[default.upper()]
 
     except ValueError:
         log_level_str = log_level_str.upper()
         try:
             return getattr(logging, log_level_str)
         except AttributeError:
-            logging.error(f"Invalid LOG_LEVEL '{log_level_str}'. Using {logging.getLevelName(default)}.")
-            return default
+            logging.error(f"Invalid LOG_LEVEL '{log_level_str}'. Using {default.upper()}.")
+            return logging._nameToLevel[default.upper()]
 
 
 egse_logger = logging.getLogger("egse")
@@ -145,7 +144,7 @@ if __name__ == "__main__":
             Environment variables:
               - LOG_LEVEL=debug|info|warning|critical
               - LOG_FORMAT=full|clean
-            
+
             Example logging statements
               - logging level set to INFO
               - logging format set to full

{cgse_common-0.17.0 → cgse_common-0.17.2}/src/egse/scpi.py

@@ -9,12 +9,18 @@ from egse.device import AsyncDeviceTransport
 from egse.device import DeviceConnectionError
 from egse.device import DeviceError
 from egse.device import DeviceTimeoutError
+from egse.env import bool_env
 from egse.log import logger
 
 DEFAULT_READ_TIMEOUT = 1.0  # seconds
 DEFAULT_CONNECT_TIMEOUT = 3.0  # seconds
 IDENTIFICATION_QUERY = "*IDN?"
 
+VERBOSE_DEBUG = bool_env("VERBOSE_DEBUG")
+
+SEPARATOR = b"\n"
+SEPARATOR_STR = SEPARATOR.decode()
+
 
 class SCPICommand:
     """Base class for SCPI commands."""
@@ -57,7 +63,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 {}
@@ -71,12 +78,15 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
         self._connect_lock = asyncio.Lock()
         """Prevents multiple, simultaneous connect or disconnect attempts."""
         self._io_lock = asyncio.Lock()
-        """Prevents multiple coroutines from attempting to read, write or query from the same stream
-        at the same time."""
+        """Prevents multiple coroutines from attempting to read, write or query from the same stream at the same time."""
 
     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 +123,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 +150,51 @@ 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}.")
+                response = await self.read_string()
+                if VERBOSE_DEBUG:
+                    logger.debug(f"Response after connection: {response}")
+
+                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 +205,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 +236,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 +245,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 +262,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 +290,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 +299,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 +319,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,35 +342,35 @@ 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 required terminator
+                if not command.endswith(SEPARATOR_STR):
+                    command += SEPARATOR_STR
 
-                logger.info(f"-----> {command}")
+                logger.info(f"-----> {command=}")
                 self._writer.write(command.encode())
                 await self._writer.drain()
 
-                # First, small delay to allow device to prepare response
+                # First, small delay to allow the device to prepare a response
                 await asyncio.sleep(0.01)
 
-                # Try to read until newline (common SCPI terminator)
+                # Try to read until the required separator (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}")
+                    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 +378,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_common-0.17.0 → cgse_common-0.17.2}/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:
@@ -375,6 +380,37 @@ class Settings:
 
         return msg.rstrip()
 
+    @classmethod
+    def from_string(cls, yaml_string: str, group: str | None = None) -> attrdict:
+        """
+        Creates a Settings object from a YAML string.
+
+        Args:
+            yaml_string (str): the YAML configuration as a string
+
+        Returns:
+            An attribute dictionary with all the settings from the given string.
+        """
+        try:
+            yaml_document = yaml.load(yaml_string, Loader=SAFE_LOADER)
+            settings = attrdict({name: value for name, value in yaml_document.items()}, label="Settings")
+        except yaml.YAMLError as exc:
+            logger.error(exc)
+            raise SettingsError("Error loading YAML document from string") from exc
+
+        if not settings:
+            logger.warning(
+                "The Settings YAML string is empty. No local settings were loaded, an empty dictionary is returned."
+            )
+
+        if group:
+            if group in settings:
+                settings = attrdict({name: value for name, value in settings[group].items()}, label=group)
+            else:
+                raise SettingsError(f"Group name '{group}' is not defined in the provided YAML string.")
+
+        return settings
+
 
 def main(args: list | None = None):  # pragma: no cover
     # We provide convenience to inspect the settings by calling this module directly from Python.

{cgse_common-0.17.0 → cgse_common-0.17.2}/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
@@ -153,7 +155,7 @@ class SocketDevice(DeviceConnectionInterface, DeviceTransport):
 
         try:
             while True:
-                # compute remaining timeout for select, this is needed because we read in different parts
+                # compute the remaining timeout for select, this is needed because we read in different parts
                 # until ETX is received, and we want to receive the complete messages including ETX within
                 # the read timeout.
                 if end_time is None:
@@ -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_common-0.17.0 → cgse_common-0.17.2}/src/egse/system.py

@@ -10,8 +10,6 @@ The module has external dependencies to:
 
 """
 
-from __future__ import annotations
-
 import asyncio
 import builtins
 import collections
@@ -30,6 +28,7 @@ import os
 import platform  # For getting the operating system name
 import re
 import shutil
+import signal
 import socket
 import subprocess  # For executing a shell command
 import sys
@@ -60,7 +59,6 @@ from rich.text import Text
 from rich.tree import Tree
 from typer.core import TyperCommand
 
-import signal
 from egse.log import logger
 
 EPOCH_1958_1970 = 378691200
@@ -107,7 +105,7 @@ class Periodic:
         interval: float,
         *,
         name: str | None = None,
-        callback: Callable = None,
+        callback: Callable | None = None,
         repeat: int | None = None,
         skip: bool = True,
         pause: bool = False,
@@ -202,7 +200,7 @@ class Periodic:
         """Triggers the Timer's action: either call its callback, or logs a message."""
 
         if self._callback is None:
-            self._logger.warning(f"Periodic – No callback provided for interval timer {self.name}.")
+            self._logger.warning(f"Periodic - No callback provided for interval timer {self.name}.")
             return
 
         try:
@@ -211,7 +209,7 @@ class Periodic:
             self._logger.debug("Caught CancelledError on callback function in Periodic.")
             raise
         except Exception as exc:
-            self._logger.error(f"{type(exc).__name__} caught: {exc}")
+            self._logger.error(f"{type_name(exc)} caught: {exc}")
 
     @property
     def interval(self):
@@ -370,8 +368,8 @@ def ignore_m_warning(modules=None):
         modules = [modules]
 
     try:
-        import warnings
         import re
+        import warnings
 
         msg = "'{module}' found in sys.modules after import of package"
         for module in modules:
@@ -390,7 +388,10 @@ def now(utc: bool = True):
 
 
 def format_datetime(
-    dt: Union[str, datetime.datetime] = None, fmt: str = None, width: int = 6, precision: int = 3
+    dt: str | datetime.datetime | datetime.date | None = None,
+    fmt: str | None = None,
+    width: int = 6,
+    precision: int = 3,
 ) -> str:
     """Format a datetime as YYYY-mm-ddTHH:MM:SS.μs+0000.
 
@@ -452,6 +453,10 @@ def format_datetime(
     if fmt:
         timestamp = dt.strftime(fmt)
     else:
+        # If dt is a date (not datetime), convert to datetime at midnight
+        if isinstance(dt, datetime.date) and not isinstance(dt, datetime.datetime):
+            dt = datetime.datetime.combine(dt, datetime.time.min)
+
         width = min(width, precision)
         timestamp = (
             f"{dt.strftime('%Y-%m-%dT%H:%M')}:"
@@ -727,18 +732,29 @@ def get_host_ip() -> Optional[str]:
     return None
 
 
-def get_current_location():
+def get_current_location() -> tuple[str, int, str]:
     """
     Returns the location where this function is called, i.e. the filename, line number, and function name.
+
+    If the location cannot be determined, ("", 0, "") is returned.
     """
-    frame = inspect.currentframe().f_back
+    frame = inspect.currentframe()
+    logger.debug(f"{frame = }")
+    if frame is None:
+        return "", 0, ""
 
-    filename = inspect.getframeinfo(frame).filename
-    line_number = inspect.getframeinfo(frame).lineno
-    function_name = inspect.getframeinfo(frame).function
+    previous_frame = frame.f_back
+    logger.debug(f"{previous_frame = }")
+    if previous_frame is None:
+        return "", 0, ""
+
+    filename = inspect.getframeinfo(previous_frame).filename
+    line_number = inspect.getframeinfo(previous_frame).lineno
+    function_name = inspect.getframeinfo(previous_frame).function
 
     # Clean up to prevent reference cycles
     del frame
+    del previous_frame
 
     return filename, line_number, function_name
 
@@ -1364,7 +1380,7 @@ def chdir(dirname=None):
 
 
 @contextlib.contextmanager
-def env_var(**kwargs: dict[str, str]):
+def env_var(**kwargs: str):
     """
     Context manager to run some code that need alternate settings for environment variables.
 
@@ -1540,6 +1556,7 @@ def read_last_lines(filename: str | Path, num_lines: int) -> List[str]:
     sanity_check(num_lines >= 0, "the number of lines to read shall be a positive number or zero.")
 
     if not filename.exists():
+        logger.warning(f"File does not exist: {filename}")
         return []
 
     # Declaring variable to implement exponential search
@@ -2321,22 +2338,44 @@ def caffeinate(pid: int = None):
         subprocess.Popen([shutil.which("caffeinate"), "-i", "-w", str(pid)])
 
 
-def redirect_output_to_log(output_fn: str, append: bool = False) -> TextIO:
+def redirect_output_to_log(output_fn: str, append: bool = False, overwrite=True) -> TextIO:
     """
-    Open file in the log folder where process output will be redirected.
-
+    Open the file in the log folder where the current process output will be redirected.
     When no location can be determined, the user's home directory will be used.
 
-    The file is opened in text mode at the given location and the stream (file descriptor) will be returned.
+    The file will be opened in text mode.
+
+    Args:
+        output_fn: the name of the output file
+        append: True to append to the file, False to overwrite
+        overwrite: when False and the file exists, an exception is raised
+
+    Returns:
+        The file stream (TextIO) where output can be redirected to.
+
+    Raises:
+        FileExistsError: when the output file exists, append is False and overwrite is False.
     """
 
-    try:
-        from egse.env import get_log_file_location
+    if Path(output_fn).is_absolute():
+        output_path = Path(output_fn)
+    else:
+        try:
+            from egse.env import get_log_file_location
+
+            location = get_log_file_location()
+            output_path = Path(location, output_fn).expanduser()
+        except ValueError:
+            output_path = Path.home() / output_fn
 
-        location = get_log_file_location()
-        output_path = Path(location, output_fn).expanduser()
-    except ValueError:
-        output_path = Path.home() / output_fn
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if output_path.exists() and not append:
+        if not overwrite:
+            raise FileExistsError(
+                f"Output file {output_path!s} already exists and will be overwritten. "
+                f"Use overwrite=True to allow overwriting."
+            )
 
     out = open(output_path, "a" if append else "w")
 

{cgse_common-0.17.0 → cgse_common-0.17.2}/src/egse/version.py

@@ -31,7 +31,7 @@ __all__ = [
 ]
 
 
-def get_version_from_settings_file_raw(group_name: str, location: Path | str = None) -> str:
+def get_version_from_settings_file_raw(group_name: str, location: Path | str | None = None) -> str:
     """
     Reads the VERSION field from the `settings.yaml` file in raw mode, meaning the file
     is not read using the PyYAML module, but using the `readline()` function of the file
@@ -66,7 +66,7 @@ def get_version_from_settings_file_raw(group_name: str, location: Path | str = N
     return version
 
 
-def get_version_from_settings(group_name: str, location: Path = None):
+def get_version_from_settings(group_name: str, location: Path | None = None, yaml_string: str | None = None) -> str:
     """
     Reads the VERSION field from the `settings.yaml` file. This function first tries to load the proper Settings
     and Group and if that fails uses the raw method.
@@ -74,6 +74,7 @@ def get_version_from_settings(group_name: str, location: Path = None):
     Args:
         group_name: major group name that contains the VERSION field, i.e. Common-EGSE or PLATO_TEST_SCRIPTS.
         location: the location of the `settings.yaml` file or None in which case the location of this file is used.
+        yaml_string: optional YAML string to read the settings from instead of a file.
 
     Raises:
         A RuntimeError when the group_name is incorrect and unknown or the VERSION field is not found.
@@ -81,10 +82,14 @@ def get_version_from_settings(group_name: str, location: Path = None):
     Returns:
         The version from the `settings.yaml` file as a string.
     """
-    from egse.settings import Settings, SettingsError
+    from egse.settings import Settings
+    from egse.settings import SettingsError
 
     try:
-        settings = Settings.load(group_name, location=location)
+        if location is None and yaml_string is not None:
+            settings = Settings.from_string(yaml_string, group=group_name)
+        else:
+            settings = Settings.load(group_name, location=location)
         version = settings.VERSION
     except (ModuleNotFoundError, SettingsError):
         version = get_version_from_settings_file_raw(group_name, location=location)
@@ -92,7 +97,7 @@ def get_version_from_settings(group_name: str, location: Path = None):
     return version
 
 
-def get_version_from_git(location: str = None):
+def get_version_from_git(location: str | Path | None = None) -> str:
     """
     Returns the Git version number for the repository at the given location.
 
@@ -121,12 +126,12 @@ def get_version_from_git(location: str = None):
             proc = subprocess.run(
                 ["git", "describe", "--tags", "--long", "--always"], stderr=subprocess.PIPE, stdout=subprocess.PIPE
             )
-            if proc.stderr:
-                version = None
             if proc.stdout:
                 version = proc.stdout.strip().decode("ascii")
+            else:
+                version = "0.0.0"
         except subprocess.CalledProcessError:
-            version = None
+            version = "0.0.0"
 
     return version
 
@@ -144,12 +149,13 @@ def get_version_installed(package_name: str) -> str:
     from egse.system import chdir
 
     with chdir(Path(__file__).parent):
-        from importlib.metadata import version, PackageNotFoundError
+        from importlib.metadata import PackageNotFoundError
+        from importlib.metadata import version as get_version
 
         try:
-            version = version(package_name)
+            version = get_version(package_name)
         except PackageNotFoundError:
-            version = None
+            version = "0.0.0"
 
     return version
 
@@ -162,11 +168,12 @@ VERSION = get_version_installed("cgse-common")
 # The __PYPI_VERSION__ is the version number that will be used for the installation.
 # The version will appear in PyPI and also as the `installed version`.
 
-__PYPI_VERSION__ = VERSION.split("+")[0]
+__PYPI_VERSION__ = VERSION.split("+")[0] if VERSION else "0.0.0"
 
 
-if __name__ == "__main__":
+def main():
     import rich
+
     from egse.plugin import entry_points
 
     if VERSION:
@@ -178,3 +185,7 @@ if __name__ == "__main__":
     for ep in entry_points("cgse.version"):
         if installed_version := get_version_installed(ep.name):
             rich.print(f"Installed version for {ep.name}= [bold default]{installed_version}[/]")
+
+
+if __name__ == "__main__":
+    main()