cgse-common 0.16.14__py3-none-any.whl → 0.17.1__py3-none-any.whl

egse/scpi.py

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

egse/settings.py

@@ -66,22 +66,20 @@ The above code will read the YAML file from the given location and not from the
 
 """
 
-from __future__ import annotations
-
-import logging
 import re
 from pathlib import Path
 from typing import Any
 
 import yaml  # This module is provided by the pip package PyYaml - pip install pyyaml
 
+from egse.env import bool_env
 from egse.env import get_local_settings_env_name
 from egse.env import get_local_settings_path
 from egse.log import logger
 from egse.system import attrdict
 from egse.system import recursive_dict_update
 
-_HERE = Path(__file__).resolve().parent
+VERBOSE_DEBUG = bool_env("VERBOSE_DEBUG")
 
 
 class SettingsError(Exception):
@@ -195,9 +193,12 @@ def load_local_settings(force: bool = False) -> attrdict:
     local_settings = attrdict()
 
     local_settings_path = get_local_settings_path()
+    if VERBOSE_DEBUG:
+        logger.debug(f"{get_local_settings_env_name()=}")
+        logger.debug(f"{local_settings_path=}")
 
     if local_settings_path:
-        path = Path(local_settings_path)
+        path = Path(local_settings_path).expanduser()
         local_settings = load_settings_file(path.parent, path.name, force)
 
     return local_settings
@@ -221,7 +222,8 @@ def read_configuration_file(filename: Path, *, force=False) -> dict:
     filename = str(filename)
 
     if force or not Settings.is_memoized(filename):
-        logger.debug(f"Parsing YAML configuration file {filename}.")
+        if VERBOSE_DEBUG:
+            logger.debug(f"Parsing YAML configuration file {filename}.")
 
         with open(filename, "r") as stream:
             try:
@@ -386,7 +388,9 @@ def main(args: list | None = None):  # pragma: no cover
     #
     # Use the '--help' option to see what your choices are.
 
-    logging.basicConfig(level=20)
+    from egse.env import setup_env
+
+    setup_env()
 
     import argparse
 

egse/setup.py

@@ -644,7 +644,7 @@ def _check_conditions_for_get_path_of_setup_file(site_id: str) -> Path:
 
     print_env()
 
-    repo_location = Path(repo_location)
+    repo_location = Path(repo_location).expanduser()
     setup_location = repo_location / "data" / site_id / "conf"
 
     if not repo_location.is_dir():
@@ -689,7 +689,7 @@ def get_path_of_setup_file(setup_id: int, site_id: str) -> Path:
     """
 
     if not has_conf_repo_location():
-        setup_location = Path(get_conf_data_location(site_id))
+        setup_location = Path(get_conf_data_location(site_id)).expanduser()
     else:
         setup_location = _check_conditions_for_get_path_of_setup_file(site_id)
 
@@ -823,10 +823,11 @@ def submit_setup(setup: Setup, description: str, **kwargs) -> str | None:
 
 def main(args: list = None):  # pragma: no cover
     import argparse
-
     from rich import print
-
     from egse.config import find_files
+    from egse.env import setup_env
+
+    setup_env()
 
     site_id = get_site_id()
     location = get_conf_data_location()
@@ -882,7 +883,7 @@ def main(args: list = None):  # pragma: no cover
 
 
 class SetupManager:
-    """Unified manager that routes Setup access to appropriate providers.
+    """A unified manager that routes Setup access to appropriate providers.
 
     Providers are loaded from the `cgse.extension.setup_providers` entrypoints.
     Providers serve different purposes, the default provider accesses Setups from
@@ -958,6 +959,11 @@ _setup_manager = SetupManager()
 
 
 if __name__ == "__main__":
+    from egse.env import setup_env
+
+    setup_env()
+
+    # import sys
     # main(sys.argv[1:])
-    #
+
     rich.print(load_setup(site_id=get_site_id()))