cgse 0.17.4__tar.gz → 0.18.1__tar.gz

{cgse-0.17.4 → cgse-0.18.1}/.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-0.18.1/.op/plugins/gh.json

@@ -0,0 +1,15 @@
+{
+	"account_id": "TH3OTWXUQRFT7O7QV447RPGKII",
+	"entrypoint": [
+		"gh"
+	],
+	"credentials": [
+		{
+			"plugin": "github",
+			"credential_type": "personal_access_token",
+			"usage_id": "personal_access_token",
+			"vault_id": "hftanxm6nbsh6dd4je5xzpmqwa",
+			"item_id": "iq66j22e5sstusksk6dwxsh7eq"
+		}
+	]
+}

{cgse-0.17.4 → cgse-0.18.1}/CHANGELOG.md

@@ -8,13 +8,61 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.18.1] - 2026-02-05
+
+This is a minor update of the DAQ6510:
+- Enhanced the DAQ6510 interface with default buffer usage, improved command formatting, and better response handling. 
+- Introduced verbose logging for socket operations in `SocketDevice`.
+- Updated sensor configuration to support multiple sensing types. 
+- Added unit tests for the DAQ6510 controller and proxy functionality to ensure reliability. 
+- Refactored the DAQ6510 monitoring script for better readability and structure.
+
+## [0.18.0] - 2026-02-04
+
+### Added
+
+- Implementation of KIKUSUI PMX-A power supply
+- The project is now licensed under the MIT license.
+
+### Changed
+
+- Refactoring Keithley DAQ6510
+  - Synchronous device, controller, control server and monitoring needed an update. 
+  - Asynchronous device and monitoring have been tested, but need an update to use the Setup for configuration.
+  - set default timeout value for Keithley DAQ6510 configuration
+  - set default port number of the DAQ6510 device to 5025
+  - the DAQ6510 synchronous device implementation is now a `SocketDevice`
+
+- on `cgse-common`
+  - improvements to the asynchronous SCPI interface
+  - some devices write an identification to the socket after connection, some devices don't. The read-after-connect can now be disabled/enabled.
+  - functions to create and inspect channel lists have been added to `scpi.py`
+  - `DeviceConnectionError` now also inherits from `ConnectionError`
+  - `SocketDevice` has been improved and now takes into account the separator that was passed into the constructor.
+
+### Fixed
+
+- The SetupManager implements a lazy initialization to prevent circular imports by plugins. The default source for the Setups was not properly updated after lazy initialization. That is now fixed.
+
 ## [0.17.4] - 2026-01-27
 
+### Added
+
 - Extracting HK from Ariel facility database
+- Implementation of Digilent MEASURpoint DT8874
+- Preliminary 1st version of the TCU UI
+- Added synchronous and asynchronous service connectors for robust service connection management with retry, backoff, and circuit breaker logic. These classes is intended to be subclassed for managing persistent connections to external services (such as devices, databases, or remote APIs) that may be unreliable or temporarily unavailable.
+- Added SocketDevice and AsyncSocketDevice implementations. Devices that connect through Ethernet can inherit from these classes to handle their basic `read()`, `write()`, `trans()`, and `query()` methods.
+
+### Changed
+
 - Re-shuffled hexapod settings
-- Cleaned up cgse-coordinates
+- Enable TCU CS to run without core services
 - Maintenance on cgse-core
-- Implementation of Digilent MEASURpoint DT8874
+
+### Fixed
+- Cleaned up cgse-coordinates, removed obsolete settings
+- Fixed timeouts and signals for Dummy device code
 
 
 ## [0.17.3] - 2025-11-29
@@ -210,7 +258,10 @@ This release is mainly on maintenance and improvements to the `cgse-common` pack
 - Renamed `cgse` subcommands `registry` →  `reg`, `notify` →  `not`.
 
 
-[Unreleased]: https://github.com/IvS-KULeuven/cgse/compare/v0.17.3...HEAD
+[Unreleased]: https://github.com/IvS-KULeuven/cgse/compare/v0.18.1...HEAD
+[0.18.1]: https://github.com/IvS-KULeuven/cgse/compare/v0.18.0...v0.18.1
+[0.18.0]: https://github.com/IvS-KULeuven/cgse/compare/v0.17.4...v0.18.0
+[0.17.4]: https://github.com/IvS-KULeuven/cgse/compare/v0.17.3...v0.17.4
 [0.17.3]: https://github.com/IvS-KULeuven/cgse/compare/v0.17.2...v0.17.3
 [0.17.2]: https://github.com/IvS-KULeuven/cgse/compare/v0.17.1...v0.17.2
 [0.17.1]: https://github.com/IvS-KULeuven/cgse/compare/v0.17.0...v0.17.1

cgse-0.18.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Instituut voor sterrenkunde - KU Leuven
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{cgse-0.17.4 → cgse-0.18.1}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: cgse
-Version: 0.17.4
+Version: 0.18.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>
 License: MIT
+License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: cgse-common
 Requires-Dist: cgse-core

cgse-0.18.1/justfile

@@ -0,0 +1,69 @@
+# 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/
+
+# print the available commands
+default:
+    @just --list
+
+# demo on using Python with Just
+hello arg="":
+  #!/usr/bin/env uv run --script
+  # /// script
+  # requires-python = ">=3.10"
+  # dependencies=["rich"]
+  # ///
+  import rich
+  print("Hello from Python!")
+  if "{{arg}}".lower() != "":
+      rich.print("A second [blue]blue line[/]... with 'Hello, {{arg}}!'")
+
+
+# What architecture and OS are we running on
+system-info:
+  @echo "This is an {{arch()}} machine, running {{os()}}".
+
+default_python := "3.10"
+
+# Start an IPython session
+ipython version=default_python:
+    #!/usr/bin/env sh
+    if [ "{{version}}" != {{default_python}} ] ; then
+        uv sync --python {{version}} --all-packages
+    fi
+    uv run --with ipython --python {{version}} ipython
+    uv sync --python {{default_python}} --all-packages --all-groups
+
+# Serve the documentation
+docs-serve:
+    uv run mkdocs serve
+
+# Build the documentation
+docs-build:
+    uv run mkdocs build
+
+# Publish the documentation
+docs-publish: docs-build
+    uv run mkdocs gh-deploy -r upstream -m "documentation update"
+
+default_part := "patch"
+
+# part can be (patch | minor | major)
+bump part=default_part:
+    #!/usr/bin/env sh
+    if [ -z "{{part}}" ] ; then
+        echo Version will not be bumped.
+    else
+        uv run bump.py --no-verbose {{part}}
+    fi
+
+# part can be (patch | minor | major)
+build part="": (bump part)
+    rm -r dist
+    uv build --all-packages
+
+# part can be (patch | minor | major)
+publish part="": (build part)
+    uv publish --token $UV_PUBLISH_TOKEN

cgse-0.18.1/libs/cgse-common/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-0.17.4 → cgse-0.18.1}/libs/cgse-common/pyproject.toml

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

{cgse-0.17.4 → cgse-0.18.1}/libs/cgse-common/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-0.17.4 → cgse-0.18.1}/libs/cgse-common/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-0.17.4 → cgse-0.18.1}/libs/cgse-common/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-0.17.4 → cgse-0.18.1}/libs/cgse-common/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-0.17.4 → cgse-0.18.1}/libs/cgse-common/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