cgse-common 0.17.3__py3-none-any.whl → 0.18.0__py3-none-any.whl

{cgse_common-0.17.3.dist-info → cgse_common-0.18.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgse-common
-Version: 0.17.3
+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.17.3.dist-info → cgse_common-0.18.0.dist-info}/RECORD

@@ -6,13 +6,13 @@ egse/calibration.py,sha256=a5JDaXTC6fMwQ1M-qrwNO31Ass-yYSXxDQUK_PPsZg4,8818
 egse/config.py,sha256=M821_d1IfNT17J3tt_TDjh4bGJgGiYviGBYR0I5v5LA,9639
 egse/counter.py,sha256=7UwBeTAu213xdNdGAOYpUWNQ4jD4yVM1bOG10Ax4UFs,5097
 egse/decorators.py,sha256=ZJgXKP8IEniOFd8nHljNeUNpQLAB2Z9q4UiQsnLFzhA,27204
-egse/device.py,sha256=gfv5Eazf1nZt3U59w9RwSWnKnAMs4hZrhb4Zv5xBvGE,11431
+egse/device.py,sha256=hHDOWUpjLU86SIMiQAH9m8P8BvdgfXoPexISOKjAWy4,13612
 egse/dicts.py,sha256=dUAq7PTPvs73OrZb2Fh3loxvYv4ifUiK6bBcgrFU77Y,3972
-egse/env.py,sha256=MWftGEmodckKbjXxFGm3WsQRnZ96wCDR3bci0KzZP0Y,31705
+egse/env.py,sha256=Lrx_G8DP8juyWx_Yh2yjhtDBesJZGMw_QWya984-Dr8,31704
 egse/exceptions.py,sha256=yhOtO5NkCxgvTyVo8fgTyxauX-ZtiEkxDB76ZdCbPrM,1301
 egse/heartbeat.py,sha256=2SeZzX3tWFog1rgYThX-iaZPwHYq8TVma2ll7r624Eg,3039
-egse/hk.py,sha256=AumSpB8SYXes75CB2iiKXfLkMK5IkVDHITFKrf8IT6g,32010
-egse/log.py,sha256=5sdVQC2DfBlHbOQzY8ChzLjoL7kNDMErTZFaj97aNBE,5350
+egse/hk.py,sha256=01ejNkJ-RxPO8NPHYB91NryMVBNF9MN5B-BsvkCvzxQ,32006
+egse/log.py,sha256=EhwzRufDOFd7vJVF8_C-q5D2NmO1TGIu6x7ske_JMZI,5547
 egse/metrics.py,sha256=2hHtJXG0Rn782l2bfmLNBbw6ucC5nf7jPnNzqbhP_Zs,7012
 egse/observer.py,sha256=xQ7F7NVHqdRZ6IIsBM5M0kMuullMghoR98dwAsjgh0s,1287
 egse/obsid.py,sha256=y87AYX5mtNEBqEtpEFEec2MhEmo1Hej3Wwi5od84wR8,5848
@@ -24,18 +24,19 @@ egse/randomwalk.py,sha256=dllGv_F4AFYanp_A5ynBsAjglYzxaPYpRCBifwQScx4,6451
 egse/reload.py,sha256=PzOE0m1tmcNcQPVFH8orMe_cMoQIIiH9Gw2anpQTC40,4717
 egse/resource.py,sha256=kzNI6kJOE6Jd5QKJs2MkVAycUpwpOTLi1qydh3NSRng,15345
 egse/response.py,sha256=F04uqOYv1ClpHgDLYZlKTuOCSldHs5TezI_4x6zf2Fw,2717
-egse/scpi.py,sha256=DBTvB_p7yaGVW1aNJ6yhxGhWCuSe2uFzMCjFOy3XmZM,13375
+egse/scpi.py,sha256=ta59pGtkfnOx8WunDaedOrrpuDw7vwsHANMWugiufzo,22541
 egse/settings.py,sha256=eiZ9eGydgF9lNBjHH8VqOgcFDxSdhO6dLs7pYA725lo,16849
 egse/settings.yaml,sha256=mz9O2QqmiptezsMvxJRLhnC1ROwIHENX0nbnhMaXUpE,190
-egse/setup.py,sha256=ezPYA3n1P3navdPR3qDxh0qJvZCzGl2bIREEP9n2w3Y,34116
+egse/setup.py,sha256=GToyqe2esIbxVn4NT3mYIPDaFJgkWZQykbgWDOwChB8,34331
 egse/signal.py,sha256=f5pyOiNW9iTSIxV_ce5stIfG0ub9MRbaekE85kQOVzs,7992
+egse/socketdevice.py,sha256=rlTX9rpQ8VKcixBD42oNJg67-qKj9IIxk2UPM_mtz6I,14672
 egse/state.py,sha256=HdU2MFOlYRbawYRZmizV6Y8MgnZrUF0bx4fXaYU-M_s,3023
-egse/system.py,sha256=DWKOWkqz5HJMW3526VN7wbMAQv1_EuY3oNeavEydUak,77517
+egse/system.py,sha256=XiMXm5tEB95TsQQsInm_9iZTRDuPqS82VyB_9XMPL8E,77697
 egse/task.py,sha256=ODSLE05f31CgWsSVcVFFq1WYUZrJMb1LioPTx6VM824,2804
 egse/version.py,sha256=vPUsCy9HYR7nKm0Sg6EDoq1JtkBKPCr3kYrt9QYM1B8,6602
 egse/zmq_ser.py,sha256=YJFupsxuvhI8TJMeS2Hem9oMMcVmSBx0rZv93gvN-hA,3263
 egse/plugins/metrics/influxdb.py,sha256=WnAqTWRkAyMSd7W2ASwUAIEwFborrv55iX-umceevFA,8162
-cgse_common-0.17.3.dist-info/METADATA,sha256=tlkWJwh-TWW4AEBHyzl5lDiXk_awl34jJcDiD08bpuI,3068
-cgse_common-0.17.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-cgse_common-0.17.3.dist-info/entry_points.txt,sha256=xJsPRIDjtADVgd_oEDHVW10wS5LG30Ox_3brVKeyCGw,168
-cgse_common-0.17.3.dist-info/RECORD,,
+cgse_common-0.18.0.dist-info/METADATA,sha256=stU8OErbxr__5BPUohIhl9VJ7_Q5dYYqav9yfZSSAYs,3068
+cgse_common-0.18.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+cgse_common-0.18.0.dist-info/entry_points.txt,sha256=xJsPRIDjtADVgd_oEDHVW10wS5LG30Ox_3brVKeyCGw,168
+cgse_common-0.18.0.dist-info/RECORD,,

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:
@@ -339,6 +339,76 @@ class AsyncDeviceTransport:
         return await self.trans(command)
 
 
+class AsyncDeviceConnectionInterface(DeviceConnectionObservable):
+    """Generic connection interface for all Device classes and Controllers.
+
+    This interface shall be implemented in the Controllers that directly connect to the
+    hardware, but also in the simulators to guarantee an identical interface as the controllers.
+
+    This interface will be implemented in the Proxy classes through the
+    YAML definitions. Therefore, the YAML files shall define at least
+    the following commands: `connect`, `disconnect`, `reconnect`, `is_connected`.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    def __enter__(self):
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.disconnect()
+
+    async def connect(self) -> None:
+        """Connect to the device controller.
+
+        Raises:
+            ConnectionError: when the connection can not be opened.
+        """
+
+        raise NotImplementedError
+
+    async def disconnect(self) -> None:
+        """Disconnect from the device controller.
+
+        Raises:
+            ConnectionError: when the connection can not be closed.
+        """
+        raise NotImplementedError
+
+    async def reconnect(self):
+        """Reconnect the device controller.
+
+        Raises:
+            ConnectionError: when the device can not  be reconnected for some reason.
+        """
+        raise NotImplementedError
+
+    async def is_connected(self) -> bool:
+        """Check if the device is connected.
+
+        Returns:
+            True if the device is connected and responds to a command, False otherwise.
+        """
+        raise NotImplementedError
+
+
+class AsyncDeviceInterface(AsyncDeviceConnectionInterface):
+    """A generic interface for all device classes."""
+
+    def is_simulator(self) -> bool:
+        """Checks whether the device is a simulator rather than a real hardware controller.
+
+        This can be useful for testing purposes or when doing actual movement simulations.
+
+        Returns:
+            True if the Device is a Simulator; False if the Device is connected to real hardware.
+        """
+
+        raise NotImplementedError
+
+
 class DeviceFactoryInterface:
     """
     Base class for creating a device factory class to access devices.

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()
 

egse/hk.py

@@ -51,8 +51,8 @@ class TmDictionaryColumns(str, Enum):
     """  # noqa
 
     STORAGE_MNEMONIC = "Storage mnemonic"
-    CORRECT_HK_NAMES = "CAM EGSE mnemonic"
-    ORIGINAL_EGSE_HK_NAMES = "Original name in EGSE"
+    CORRECT_HK_NAMES = "CGSE mnemonic"
+    ORIGINAL_EGSE_HK_NAMES = "Original name in CGSE"
     SYNOPTICS_ORIGIN = f"Origin of synoptics at {get_site_id()}"
     TIMESTAMP_NAMES = "Name of corresponding timestamp"
     DESCRIPTION = "Description"

egse/log.py

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

egse/scpi.py

@@ -1,20 +1,28 @@
 import asyncio
+import re
 import socket
 from typing import Any
 from typing import Dict
 from typing import Optional
 
+from egse.device import AsyncDeviceInterface
 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
 
-# Constants that can be overridden by specific device implementations
 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")
+
+SEPARATOR = b"\n"
+SEPARATOR_STR = SEPARATOR.decode()
+
 
 class SCPICommand:
     """Base class for SCPI commands."""
@@ -32,7 +40,7 @@ class SCPICommand:
         raise NotImplementedError("Subclasses must implement get_cmd_string().")
 
 
-class AsyncSCPIInterface(AsyncDeviceTransport):
+class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
     """Generic asynchronous interface for devices that use SCPI commands over Ethernet."""
 
     def __init__(
@@ -43,6 +51,7 @@ class AsyncSCPIInterface(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.
@@ -54,14 +63,18 @@ class AsyncSCPIInterface(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
         """
-        self.device_name = device_name
+        super().__init__()
+
+        self._device_name = device_name
         self.hostname = hostname
         self.port = port
         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
@@ -70,8 +83,88 @@ class AsyncSCPIInterface(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 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
+        executing a sequence of commands. Each command can optionally expect a
+        response that will be logged for debugging purposes.
+
+        Args:
+            commands: List of tuples containing (command_string, expects_response).
+                Each tuple specifies a command to send and whether to wait for and
+                log the response. Defaults to None (no commands executed).
+            reset_device: Whether to send a reset command (*RST) before executing
+                the command sequence. Defaults to False.
+
+        Returns:
+           Response for each of the commands, or None when no response was expected.
+
+        Raises:
+            Any exceptions raised by the underlying write() or trans() methods,
+            typically communication errors or device timeouts.
+
+        Example:
+            await device.initialize(
+                [
+                    ("*IDN?", True),           # Query device ID, expect response
+                    ("SYST:ERR?", True),       # Check for errors, expect response
+                    ("OUTP ON", False),        # Enable output, no response expected
+                ],
+                reset_device=True
+            )
+        """
+
+        commands = commands or []
+        responses = []
+
+        if reset_device:
+            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:
+            if expects_response:
+                logger.debug(f"Sending {cmd}...")
+                response = (await self.trans(cmd)).decode().strip()
+                responses.append(response)
+                logger.debug(f"{response = }")
+            else:
+                logger.debug(f"Sending {cmd}...")
+                await self.write(cmd)
+                responses.append(None)
+
+        return responses
 
     async def connect(self) -> None:
         """Connect to the device asynchronously.
@@ -84,47 +177,54 @@ class AsyncSCPIInterface(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
+
+            # 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..")
                 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.
@@ -135,22 +235,20 @@ class AsyncSCPIInterface(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."""
-        async with self._connect_lock:
-            if self._is_connection_open:
-                await self.disconnect()
-                await asyncio.sleep(0.1)
-            await self.connect()
+        await self.disconnect()
+        await asyncio.sleep(0.1)
+        await self.connect()
 
     async def is_connected(self) -> bool:
         """Check if the device is connected and responds correctly to identification.
@@ -168,7 +266,7 @@ class AsyncSCPIInterface(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()
@@ -177,8 +275,7 @@ class AsyncSCPIInterface(AsyncDeviceTransport):
             return True
 
         except DeviceError as exc:
-            logger.exception(exc)
-            logger.error(f"{self.device_name}: Connection test failed")
+            logger.error(f"{self._device_name}: Connection test failed: {exc}", exc_info=True)
             await self.disconnect()
             return False
 
@@ -195,19 +292,21 @@ class AsyncSCPIInterface(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
 
+                if VERBOSE_DEBUG:
+                    logger.debug(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:
         """
@@ -222,7 +321,7 @@ class AsyncSCPIInterface(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
@@ -231,18 +330,20 @@ class AsyncSCPIInterface(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
                     )
+                    if VERBOSE_DEBUG:
+                        logger.debug(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
@@ -250,9 +351,9 @@ class AsyncSCPIInterface(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:
         """
@@ -272,34 +373,39 @@ class AsyncSCPIInterface(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")
+                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
 
-                # Ensure command ends with newline
-                if not command.endswith("\n"):
-                    command += "\n"
+                if VERBOSE_DEBUG:
+                    logger.debug(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
                     )
+                    if VERBOSE_DEBUG:
+                        logger.debug(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
@@ -307,11 +413,11 @@ class AsyncSCPIInterface(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."""
@@ -321,3 +427,156 @@ class AsyncSCPIInterface(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

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
 

egse/socketdevice.py

@@ -0,0 +1,379 @@
+"""
+This module defines base classes and generic functions to work with sockets.
+"""
+
+import asyncio
+import select
+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
+from egse.device import DeviceTransport
+from egse.log import logger
+from egse.system import type_name
+
+SEPARATOR = b"\x03"
+SEPARATOR_STR = SEPARATOR.decode()
+
+
+class SocketDevice(DeviceConnectionInterface, DeviceTransport):
+    """Base class that implements the socket interface."""
+
+    # We set a default connect timeout of 3.0 sec before connecting and reset
+    # to None (=blocking) after connecting. The reason for this is that when no
+    # device is available, e.g. during testing, the timeout will take about
+    # two minutes which is way too long. It needs to be evaluated if this
+    # approach is acceptable and not causing problems during production.
+
+    def __init__(
+        self,
+        hostname: str,
+        port: int,
+        connect_timeout: float = 3.0,
+        read_timeout: float | None = 1.0,
+        separator: bytes = SEPARATOR,
+    ):
+        super().__init__()
+        self.is_connection_open = False
+        self.hostname = hostname
+        self.port = port
+        self.connect_timeout = connect_timeout
+        self.read_timeout = read_timeout
+        self.separator = separator
+        self.separator_str = separator.decode()
+        self.socket = None
+
+    @property
+    def device_name(self):
+        """The name of the device that this interface connects to."""
+        return f"SocketDevice({self.hostname}:{self.port})"
+
+    def connect(self):
+        """
+        Connect the device.
+
+        Raises:
+            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.
+        """
+
+        # Sanity checks
+
+        if self.is_connection_open:
+            logger.warning(f"{self.device_name}: trying to connect to an already connected socket.")
+            return
+
+        if self.hostname in (None, ""):
+            raise ValueError(f"{self.device_name}: hostname is not initialized.")
+
+        if self.port in (None, 0):
+            raise ValueError(f"{self.device_name}: port number is not initialized.")
+
+        # Create a new socket instance
+
+        try:
+            self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        except socket.error as exc:
+            raise ConnectionError(f"{self.device_name}: Failed to create socket.") from exc
+
+        try:
+            logger.debug(f'Connecting a socket to host "{self.hostname}" using port {self.port}')
+            self.socket.settimeout(self.connect_timeout)
+            self.socket.connect((self.hostname, self.port))
+            self.socket.settimeout(None)
+        except ConnectionRefusedError as exc:
+            raise ConnectionError(f"{self.device_name}: Connection refused to {self.hostname}:{self.port}.") from exc
+        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
+        except socket.herror as 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
+
+        self.is_connection_open = True
+
+    def disconnect(self):
+        """
+        Disconnect from the Ethernet connection.
+
+        Raises:
+            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}")
+                self.socket.close()
+                self.is_connection_open = False
+        except Exception as e_exc:
+            raise ConnectionError(f"{self.device_name}: Could not close socket to {self.hostname}") from e_exc
+
+    def is_connected(self) -> bool:
+        """
+        Check if the device is connected.
+
+        Returns:
+             True is the device is connected, False otherwise.
+        """
+
+        return bool(self.is_connection_open)
+
+    def reconnect(self):
+        """
+        Reconnect to the device. If the connection is open, this function will first disconnect
+        and then connect again.
+        """
+
+        if self.is_connection_open:
+            self.disconnect()
+        self.connect()
+
+    def read(self) -> bytes:
+        """
+        Read until ETX (b'\x03') or until `self.read_timeout` elapses.
+        Uses `select` to avoid blocking indefinitely when no data is available.
+        If `self.read_timeout` was set to None in the constructor, this will block anyway.
+        """
+        if not self.socket:
+            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 behavior; otherwise enforce overall timeout.
+        if self.read_timeout is None:
+            end_time = None
+        else:
+            end_time = time.monotonic() + self.read_timeout
+
+        try:
+            while True:
+                # 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:
+                    timeout = None
+                else:
+                    remaining = end_time - time.monotonic()
+                    if remaining <= 0.0:
+                        raise DeviceTimeoutError(self.device_name, "Socket read timed out")
+                    timeout = remaining
+
+                ready, _, _ = select.select([self.socket], [], [], timeout)
+
+                if not ready:
+                    # no socket ready within timeout
+                    raise DeviceTimeoutError(self.device_name, "Socket read timed out")
+
+                try:
+                    data = self.socket.recv(buf_size)
+                except OSError as exc:
+                    raise DeviceConnectionError(self.device_name, f"Caught {type_name(exc)}: {exc}") from exc
+
+                if not data:
+                    # remote closed connection (EOF)
+                    raise DeviceConnectionError(self.device_name, "Connection closed by peer")
+
+                response.extend(data)
+
+                if self.separator in response:
+                    break
+
+        except DeviceTimeoutError:
+            raise
+        except DeviceConnectionError:
+            raise
+        except Exception as exc:
+            # unexpected errors - translate to DeviceConnectionError
+            raise DeviceConnectionError(self.device_name, "Socket read error") from exc
+
+        return bytes(response)
+
+    def write(self, command: str):
+        """
+        Send a command to the device.
+
+        No processing is done on the command string, except for the encoding into a bytes object.
+
+        Args:
+            command: the command string including terminators.
+
+        Raises:
+            A DeviceTimeoutError when the send timed out, and a DeviceConnectionError if
+            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
+        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
+
+    def trans(self, command: str) -> bytes:
+        """
+        Send a command to the device and wait for the response.
+
+        No processing is done on the command string, except for the encoding into a bytes object.
+
+        Args:
+            command: the command string including terminators.
+
+        Returns:
+            A bytes object containing the response from the device. No processing is done
+            on the response.
+
+        Raises:
+            A DeviceTimeoutError when the send timed out, and a DeviceConnectionError if
+            there was a socket related error.
+        """
+
+        if not self.socket:
+            raise DeviceConnectionError(self.device_name, "The device is not connected, connect before writing.")
+
+        self.write(command)
+
+        response = self.read()
+
+        return response
+
+
+class AsyncSocketDevice(AsyncDeviceInterface, AsyncDeviceTransport):
+    """
+    Async socket-backed device using asyncio streams.
+
+    - async connect() / disconnect()
+    - async read() reads until ETX (b'\\x03') or timeout
+    - async write() and async trans()
+    """
+
+    def __init__(
+        self,
+        hostname: str,
+        port: int,
+        connect_timeout: float = 3.0,
+        read_timeout: float | None = 1.0,
+        separator: bytes = SEPARATOR,
+    ):
+        super().__init__()
+        self.hostname = hostname
+        self.port = port
+        self.connect_timeout = connect_timeout
+        self.read_timeout = read_timeout
+        self.separator = separator
+        self.reader: Optional[asyncio.StreamReader] = None
+        self.writer: Optional[asyncio.StreamWriter] = None
+        self.is_connection_open = False
+
+    @property
+    def device_name(self) -> str:
+        # Override this property for a decent name
+        return f"AsyncSocketDevice({self.hostname}:{self.port})"
+
+    async def connect(self) -> None:
+        if self.is_connection_open:
+            logger.debug(f"{self.device_name}: already connected")
+            return
+
+        if not self.hostname:
+            raise ValueError(f"{self.device_name}: hostname is not initialized.")
+        if not self.port:
+            raise ValueError(f"{self.device_name}: port is not initialized.")
+
+        try:
+            logger.debug(f"{self.device_name}: connect() called; is_connection_open={self.is_connection_open}")
+            coro = asyncio.open_connection(self.hostname, self.port)
+            self.reader, self.writer = await asyncio.wait_for(coro, timeout=self.connect_timeout)
+            self.is_connection_open = True
+            logger.debug(f"{self.device_name}: connected -> peer={self.writer.get_extra_info('peername')}")
+
+        except asyncio.TimeoutError as exc:
+            await self._cleanup()
+            logger.warning(f"{self.device_name}: connect timed out")
+            raise DeviceTimeoutError(self.device_name, f"Connection to {self.hostname}:{self.port} timed out.") from exc
+        except Exception as exc:
+            await self._cleanup()
+            logger.warning(f"{self.device_name}: connect failed: {type_name(exc)} – {exc}")
+            raise DeviceConnectionError(self.device_name, f"Failed to connect to {self.hostname}:{self.port}") from exc
+
+    async def disconnect(self) -> None:
+        logger.debug(f"{self.device_name}: disconnect() called; writer_exists={bool(self.writer)}")
+        peer = None
+        try:
+            if self.writer and not self.writer.is_closing():
+                peer = self.writer.get_extra_info("peername")
+                self.writer.close()
+                # wait for close, but don't hang forever
+                try:
+                    await asyncio.wait_for(self.writer.wait_closed(), timeout=1.0)
+                except asyncio.TimeoutError:
+                    logger.debug(f"{self.device_name}: wait_closed() timed out for peer={peer}")
+
+        finally:
+            await self._cleanup()
+            logger.debug(f"{self.device_name}: disconnected ({peer=})")
+
+    def is_connected(self) -> bool:
+        return bool(self.is_connection_open and self.writer and not self.writer.is_closing())
+
+    async def _cleanup(self) -> None:
+        self.reader = None
+        self.writer = None
+        self.is_connection_open = False
+
+    async def read(self) -> bytes:
+        if not self.reader:
+            raise DeviceConnectionError(self.device_name, "Not connected")
+        try:
+            # readuntil includes the separator; we keep it for parity with existing code
+            data = await asyncio.wait_for(self.reader.readuntil(separator=self.separator), timeout=self.read_timeout)
+            return data
+        except asyncio.IncompleteReadError as exc:
+            # EOF before separator
+            await self._cleanup()
+            raise DeviceConnectionError(self.device_name, "Connection closed while reading") from exc
+        except asyncio.TimeoutError as exc:
+            raise DeviceTimeoutError(self.device_name, "Socket read timed out") from exc
+        except Exception as exc:
+            await self._cleanup()
+            raise DeviceConnectionError(self.device_name, "Socket read error") from exc
+
+    async def write(self, command: str) -> None:
+        if not self.writer:
+            raise DeviceConnectionError(self.device_name, "Not connected")
+        try:
+            self.writer.write(command.encode())
+            await asyncio.wait_for(self.writer.drain(), timeout=self.read_timeout)
+        except asyncio.TimeoutError as exc:
+            raise DeviceTimeoutError(self.device_name, "Socket write timed out") from exc
+        except Exception as exc:
+            await self._cleanup()
+            raise DeviceConnectionError(self.device_name, "Socket write error") from exc
+
+    async def trans(self, command: str) -> bytes:
+        if not self.writer or not self.reader:
+            raise DeviceConnectionError(self.device_name, "Not connected")
+        try:
+            await self.write(command)
+            return await self.read()
+        except (DeviceTimeoutError, DeviceConnectionError):
+            raise
+        except Exception as exc:
+            await self._cleanup()
+            raise DeviceConnectionError(self.device_name, "Socket trans error") from exc

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)
@@ -2283,6 +2283,11 @@ def kebab_to_title(kebab_str: str) -> str:
     return kebab_str.replace("-", " ").title()
 
 
+def title_to_kebab(title_str: str) -> str:
+    """Convert Title Case (each word capitalized) to kebab-case"""
+    return title_str.replace(" ", "-").lower()
+
+
 def snake_to_title(snake_str: str) -> str:
     """Convert snake_case to Title Case (each word capitalized)"""
     return snake_str.replace("_", " ").title()