cgse-common 0.17.4__tar.gz → 0.18.0__tar.gz

{cgse_common-0.17.4 → cgse_common-0.18.0}/.gitignore

@@ -22,9 +22,14 @@ dist
 .nox
 htmlcov
 
-# Virtual environments
+# dotenv, ignore all but the example file
 
 .env
+.env.*
+!.env.example
+
+# Virtual environments
+
 .venv
 venv
 

{cgse_common-0.17.4 → cgse_common-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgse-common
-Version: 0.17.4
+Version: 0.18.0
 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.18.0/justfile

@@ -0,0 +1,20 @@
+# If you don't have 'just' installed, install it with the following command:
+#
+# $  uv tool install rust-just
+#
+# The 'just' website: https://just.systems/man/en/
+
+default:
+    @just --list
+
+typecheck:
+    uv run --with mypy mypy -p egse --strict
+
+test:
+    uv run pytest -v
+
+format:
+    uvx ruff format
+
+check:
+    uvx ruff check --no-fix

{cgse_common-0.17.4 → cgse_common-0.18.0}/pyproject.toml

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

{cgse_common-0.17.4 → cgse_common-0.18.0}/src/egse/device.py

@@ -54,7 +54,7 @@ class DeviceControllerError(DeviceError):
         super().__init__(device_name, message)
 
 
-class DeviceConnectionError(DeviceError):
+class DeviceConnectionError(DeviceError, ConnectionError):
     """A generic error for all connection type of problems.
 
     Args:

{cgse_common-0.17.4 → cgse_common-0.18.0}/src/egse/env.py

@@ -170,7 +170,7 @@ def setup_env():
         return
 
     if VERBOSE_DEBUG:
-        logger.debug(f"Initialising the environment...")
+        logger.debug("Initializing the environment...")
 
     load_dotenv()
 

{cgse_common-0.17.4 → cgse_common-0.18.0}/src/egse/log.py

@@ -131,12 +131,14 @@ for handler in root_logger.handlers:
         handler.addFilter(NonEGSEFilter())
         handler.addFilter(PackageFilter())
 
-try:
-    from textual.logging import TextualHandler
-
-    root_logger.addHandler(TextualHandler())
-except ImportError:
-    pass
+# Optional: integrate with Textual logging if available
+#
+# try:
+#     from textual.logging import TextualHandler
+
+#     root_logger.addHandler(TextualHandler())
+# except ImportError:
+#     pass
 
 
 logger = egse_logger

{cgse_common-0.17.4 → cgse_common-0.18.0}/src/egse/scpi.py

@@ -1,4 +1,5 @@
 import asyncio
+import re
 import socket
 from typing import Any
 from typing import Dict
@@ -14,6 +15,7 @@ from egse.log import logger
 
 DEFAULT_READ_TIMEOUT = 1.0  # seconds
 DEFAULT_CONNECT_TIMEOUT = 3.0  # seconds
+DEFAULT_READ_AFTER_CONNECT = False
 IDENTIFICATION_QUERY = "*IDN?"
 
 VERBOSE_DEBUG = bool_env("VERBOSE_DEBUG")
@@ -49,6 +51,7 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
         settings: Optional[Dict[str, Any]] = None,
         connect_timeout: float = DEFAULT_CONNECT_TIMEOUT,
         read_timeout: float = DEFAULT_READ_TIMEOUT,
+        read_after_connect: bool = DEFAULT_READ_AFTER_CONNECT,
         id_validation: Optional[str] = None,
     ):
         """Initialize an asynchronous Ethernet interface for SCPI communication.
@@ -60,6 +63,7 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
             settings: Additional device-specific settings
             connect_timeout: Timeout for connection attempts in seconds
             read_timeout: Timeout for read operations in seconds
+            read_after_connect: Whether to perform a read operation immediately after connecting
             id_validation: String that should appear in the device's identification response
         """
         super().__init__()
@@ -70,6 +74,7 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
         self.settings = settings or {}
         self.connect_timeout = connect_timeout
         self.read_timeout = read_timeout
+        self.read_after_connect = read_after_connect
         self.id_validation = id_validation
 
         self._reader = None
@@ -87,7 +92,29 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
     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]:
+    async def get_idn_parts(self) -> list[str]:
+        """Get the device identification string and return its parts.
+
+        The *IDN? command is sent to the device, and the response is split into its
+        components: Manufacturer, Model, Serial Number, Firmware Version.
+
+        Returns:
+            A list containing Manufacturer, Model, Serial Number, Firmware Version.
+
+        Raises:
+            DeviceError: When the device is not connected or communication fails.
+        """
+        if not self._is_connection_open:
+            raise DeviceError(self._device_name, "Device not connected, use connect() first")
+
+        idn_str = (await self.query(IDENTIFICATION_QUERY)).decode().strip()
+        if VERBOSE_DEBUG:
+            logger.debug(f"{self._device_name} IDN response: {idn_str}")
+        return idn_str.split(",")
+
+    async def initialize(
+        self, commands: list[tuple[str, bool]] | None = None, reset_device: bool = False
+    ) -> list[str | None]:
         """Initialize the device with optional reset and command sequence.
 
         Performs device initialization by optionally resetting the device and then
@@ -168,10 +195,6 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
 
                 self._is_connection_open = True
 
-                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:
@@ -189,6 +212,13 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
             except OSError as exc:
                 raise DeviceConnectionError(self._device_name, f"OS error: {exc}") from exc
 
+            # Some devices require an initial read after connection.
+            # We have to read this message from the buffer and can do some version checking if needed.
+            if self.read_after_connect:
+                response = await self.read_string()
+                if VERBOSE_DEBUG:
+                    logger.debug(f"Response after connection: {response}")
+
             # Validate device identity if requested
             if self.id_validation:
                 logger.debug("Validating connection..")
@@ -268,7 +298,8 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
                 if not command.endswith(SEPARATOR_STR):
                     command += SEPARATOR_STR
 
-                logger.info(f"-----> {command}")
+                if VERBOSE_DEBUG:
+                    logger.debug(f"-----> {command}")
                 self._writer.write(command.encode())
                 await self._writer.drain()
 
@@ -301,7 +332,8 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
                     response = await asyncio.wait_for(
                         self._reader.readuntil(separator=SEPARATOR), timeout=self.read_timeout
                     )
-                    logger.info(f"<----- {response}")
+                    if VERBOSE_DEBUG:
+                        logger.debug(f"<----- {response}")
                     return response
 
                 except asyncio.IncompleteReadError as exc:
@@ -341,14 +373,16 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
 
         async with self._io_lock:
             try:
-                if not self._is_connection_open or self._writer is None:
+                if not self._is_connection_open or self._writer is None or self._reader is None:
                     raise DeviceConnectionError(self._device_name, "Device not connected, use connect() first")
 
                 # Ensure command ends with the required terminator
                 if not command.endswith(SEPARATOR_STR):
                     command += SEPARATOR_STR
 
-                logger.info(f"-----> {command=}")
+                if VERBOSE_DEBUG:
+                    logger.debug(f"-----> {command=}")
+
                 self._writer.write(command.encode())
                 await self._writer.drain()
 
@@ -360,7 +394,8 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
                     response = await asyncio.wait_for(
                         self._reader.readuntil(separator=SEPARATOR), timeout=self.read_timeout
                     )
-                    logger.info(f"<----- {response=}")
+                    if VERBOSE_DEBUG:
+                        logger.debug(f"<----- {response=}")
                     return response
 
                 except asyncio.IncompleteReadError as exc:
@@ -392,3 +427,156 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """Async context manager exit."""
         await self.disconnect()
+
+
+def create_channel_list(*args) -> str:
+    """
+    Create a channel list that is understood by SCPI commands.
+
+    Channel names are device-specific.
+
+    For the DAQ6510: Channel names contain both the slot number and the channel number.
+    The slot number is the number of the slot where the card is installed at the back of
+    the device.
+
+    When addressing multiple individual channels, add each of them as a separate argument,
+    e.g. to include channels 1, 3, and 7 from slot 1, use the following command:
+
+        >>> create_channel_list(101, 103, 107)
+        '(@101, 103, 107)'
+
+    To designate a range of channels, only one argument should be given, i.e. a tuple containing
+    two channel representing the range. The following tuple `(101, 110)` will create the
+    following response: `"(@101:110)"`. The range is inclusive, so this will define a range of
+    10 channels in slot 1.
+
+        >>> create_channel_list((201, 205))
+        '(@201:205)'
+
+    See reference manual for the Keithley DAQ6510 [DAQ6510-901-01 Rev. B / September 2019],
+    chapter 11: Introduction to SCPI commands, SCPI command formatting, channel naming.
+
+    Args:
+        *args: a tuple or a list of channels
+
+    Returns:
+        A string containing the channel list as understood by the SCPI device.
+
+    """
+    if not args:
+        return ""
+
+    # If only one argument is given, I expect either a tuple defining a range
+    # or just one channel. When several arguments are given, I expect them all
+    # to be individual channels.
+
+    ch_list = []
+    for arg in args:
+        if isinstance(arg, (tuple, list)):
+            match len(arg):
+                case 2:
+                    ch_list.append(f"{arg[0]}:{arg[1]}")
+                case 1:
+                    ch_list.append(f"{arg[0]}")
+                case _:
+                    raise ValueError(
+                        "Invalid argument: when providing a tuple or list, it must contain one or two elements."
+                    )
+        else:
+            ch_list.append(f"{arg}")
+
+    # else:
+    # ch_list = "(@" + ",".join([str(arg) for arg in args]) + ")"
+
+    return "(@" + ",".join(x for x in ch_list if x.isdigit() or ":" in x) + ")"
+
+
+def count_number_of_channels(channel_list: str) -> int:
+    """
+    Given a proper channel list, this function counts the number of channels.
+    For ranges, it returns the actual number of channels that are included in the range.
+
+        >>> count_number_of_channels("(@1,2,3,4,5)")
+        5
+        >>> count_number_of_channels("(@1, 3, 5)")
+        3
+        >>> count_number_of_channels("(@2:7)")
+        6
+
+    Args:
+        channel_list: a channel list as understood by the SCPI commands of DAQ6510.
+
+    Returns:
+        The number of channels in the list.
+    """
+
+    match = re.match(r"\(@(.*)\)", channel_list)
+    if match is None:
+        logger.error(f"Invalid channel specification in '{channel_list}'")
+        return 0
+    group = match.groups()[0]
+
+    parts = group.replace(" ", "").split(",")
+
+    try:
+        count = 0
+        for part in parts:
+            if ":" in part:
+                channels = part.split(":")
+                if len(channels) != 2:
+                    raise ValueError()
+                count += int(channels[1]) - int(channels[0]) + 1
+            else:
+                if not part.isdigit():
+                    raise ValueError()
+                count += 1
+    except ValueError:
+        logger.error(f"Invalid channel specification in '{channel_list}'")
+        return 0
+
+    return count
+
+
+def get_channel_names(channel_list: str) -> list[str]:
+    """
+    Generate a list of channel names from a given channel list.
+
+    Args:
+        channel_list: a channel list as understood by the SCPI.
+
+    Returns:
+        A list of channel names.
+    """
+
+    match = re.match(r"\(@(.*)\)", channel_list)
+    if match is None:
+        logger.error(f"Invalid channel specification in '{channel_list}'")
+        return []
+
+    group = match.groups()[0]
+
+    parts = group.replace(" ", "").split(",")
+
+    try:
+        names: list[str] = []
+
+        for part in parts:
+            if ":" in part:
+                channels = part.split(":")
+                if len(channels) != 2:
+                    raise ValueError()
+                names.extend(str(ch) for ch in range(int(channels[0]), int(channels[1]) + 1))
+            else:
+                if not part.isdigit():
+                    raise ValueError()
+                names.append(part)
+
+        # If there are still any invalid names, raise an error
+        if not all(True if x and x.isdigit() else False for x in names):
+            raise ValueError()
+
+    except ValueError:
+        logger.error(f"Invalid channel specification in '{channel_list}'")
+        return []
+
+    return names

{cgse_common-0.17.4 → cgse_common-0.18.0}/src/egse/setup.py

@@ -936,9 +936,13 @@ class SetupManager:
     def set_default_source(self, source: str):
         self._default_source = source
 
-    def load_setup(self, setup_id: int = None, **kwargs):
-        source = kwargs.get("source") or self._default_source
+    def get_default_source(self):
+        # Trigger provider discovery because they can change the default source if they handle core-services
+        _ = self.providers
+        return self._default_source
 
+    def load_setup(self, setup_id: int = None, **kwargs):
+        source = kwargs.get("source") or self.get_default_source()
         for provider in self.providers:
             if provider.can_handle(source):
                 return provider.load_setup(setup_id, **kwargs)
@@ -947,7 +951,7 @@ class SetupManager:
         return LocalSetupProvider().load_setup(setup_id, **kwargs)
 
     def submit_setup(self, setup: Setup, description: str, **kwargs):
-        source = kwargs.get("source") or self._default_source
+        source = kwargs.get("source") or self.get_default_source()
         for provider in self.providers:
             if provider.can_handle(source):
                 return provider.submit_setup(setup, description, **kwargs)
@@ -957,7 +961,6 @@ class SetupManager:
 
 _setup_manager = SetupManager()
 
-
 if __name__ == "__main__":
     from egse.env import setup_env
 

{cgse_common-0.17.4 → cgse_common-0.18.0}/src/egse/socketdevice.py

@@ -45,6 +45,7 @@ class SocketDevice(DeviceConnectionInterface, DeviceTransport):
         self.connect_timeout = connect_timeout
         self.read_timeout = read_timeout
         self.separator = separator
+        self.separator_str = separator.decode()
         self.socket = None
 
     @property
@@ -57,8 +58,8 @@ class SocketDevice(DeviceConnectionInterface, DeviceTransport):
         Connect the device.
 
         Raises:
-            ConnectionError: When the connection could not be established. Check the logging
-                messages for more detail.
+            ConnectionError: When the connection could not be established.
+                Check the logging messages for more detail.
             TimeoutError: When the connection timed out.
             ValueError: When hostname or port number are not provided.
         """
@@ -92,9 +93,9 @@ class SocketDevice(DeviceConnectionInterface, DeviceTransport):
         except TimeoutError as exc:
             raise TimeoutError(f"{self.device_name}: Connection to {self.hostname}:{self.port} timed out.") from exc
         except socket.gaierror as exc:
-            raise ConnectionError(f"{self.device_name}: socket address info error for {self.hostname}") from exc
+            raise ConnectionError(f"{self.device_name}: Socket address info error for {self.hostname}") from exc
         except socket.herror as exc:
-            raise ConnectionError(f"{self.device_name}: socket host address error for {self.hostname}") from exc
+            raise ConnectionError(f"{self.device_name}: Socket host address error for {self.hostname}") from exc
         except OSError as exc:
             raise ConnectionError(f"{self.device_name}: OSError caught ({exc}).") from exc
 
@@ -108,6 +109,8 @@ class SocketDevice(DeviceConnectionInterface, DeviceTransport):
             ConnectionError when the socket could not be closed.
         """
 
+        assert self.socket is not None  # extra check + for mypy type checking
+
         try:
             if self.is_connection_open:
                 logger.debug(f"Disconnecting from {self.hostname}")
@@ -143,12 +146,12 @@ class SocketDevice(DeviceConnectionInterface, DeviceTransport):
         If `self.read_timeout` was set to None in the constructor, this will block anyway.
         """
         if not self.socket:
-            raise DeviceConnectionError(self.device_name, "Not connected")
+            raise DeviceConnectionError(self.device_name, "The device is not connected, connect before reading.")
 
         buf_size = 1024 * 4
         response = bytearray()
 
-        # If read_timeout is None we preserve blocking behaviour; otherwise enforce overall timeout.
+        # If read_timeout is None we preserve blocking behavior; otherwise enforce overall timeout.
         if self.read_timeout is None:
             end_time = None
         else:
@@ -211,7 +214,11 @@ class SocketDevice(DeviceConnectionInterface, DeviceTransport):
             there was a socket related error.
         """
 
+        if not self.socket:
+            raise DeviceConnectionError(self.device_name, "The device is not connected, connect before writing.")
+
         try:
+            command += self.separator_str if not command.endswith(self.separator_str) else ""
             self.socket.sendall(command.encode())
         except socket.timeout as exc:
             raise DeviceTimeoutError(self.device_name, "Socket timeout error") from exc
@@ -237,22 +244,14 @@ class SocketDevice(DeviceConnectionInterface, DeviceTransport):
             there was a socket related error.
         """
 
-        try:
-            # Attempt to send the complete command
-
-            self.socket.sendall(command.encode())
-
-            # wait for, read and return the response (will be at most TBD chars)
+        if not self.socket:
+            raise DeviceConnectionError(self.device_name, "The device is not connected, connect before writing.")
 
-            return_string = self.read()
+        self.write(command)
 
-            return return_string
+        response = self.read()
 
-        except socket.timeout as exc:
-            raise DeviceTimeoutError(self.device_name, "Socket timeout error") from exc
-        except socket.error as exc:
-            # Interpret any socket-related error as an I/O error
-            raise DeviceConnectionError(self.device_name, "Socket communication error.") from exc
+        return response
 
 
 class AsyncSocketDevice(AsyncDeviceInterface, AsyncDeviceTransport):

{cgse_common-0.17.4 → cgse_common-0.18.0}/src/egse/system.py

@@ -379,7 +379,7 @@ def ignore_m_warning(modules=None):
         pass
 
 
-def now(utc: bool = True):
+def now(utc: bool = True) -> datetime.datetime:
     """Returns a datetime object for the current time in UTC or local time."""
     if utc:
         return datetime.datetime.now(tz=datetime.timezone.utc)