cgse 0.15.1__tar.gz → 0.16.0__tar.gz

{cgse-0.15.1 → cgse-0.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgse
-Version: 0.15.1
+Version: 0.16.0
 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>

{cgse-0.15.1 → cgse-0.16.0}/docs/dev_guide/installation.md

@@ -43,7 +43,7 @@ Now you will have to create a virtual environment and populated it with all the
 
     The following three commands will get you going quickly:
     ```
-    $ uv venv --python 3.9.20
+    $ uv venv --python 3.10
     $ uv sync --all-packages
     $ uv run cgse
     

{cgse-0.15.1 → cgse-0.16.0}/docs/dev_guide/plugins.md

@@ -163,17 +163,26 @@ explore = "<package>.cgse_explore"
 So, what happens is that a command that wants to apply a functionality on an external package 
 loads the `cgse_explore.py` module for that package and checks if a function with a specific 
 name exists in that module. It then executes that function. For the `show procs` command, the 
-function `show_processes` is expected and it shall return a list of strings which currently are 
-printed to the terminal. This entry-point is currently implemented for `cgse-core` and 
+function `show_processes` is expected, and it shall return a list of ProcessInfo objects which 
+will be used to print a nice process table. This entry-point is currently implemented for `cgse-core` and 
 `cgse-dummy` (an external demo package) and when you run the `cgse show procs` command it looks 
 something like below (the format is from the unix `ps -ef` command). 
 
 ```text
-➜  cgse show procs
-459800007 76849     1   0 11:07PM ttys003    0:03.53 /Users/rik/tmp/test_dummy/venv/bin/python3.9 -m egse.logger.log_cs start
-459800007 76850     1   0 11:07PM ttys003    2:18.60 /Users/rik/tmp/test_dummy/venv/bin/python3.9 -m egse.storage.storage_cs start
-459800007 76851     1   0 11:07PM ttys003    2:20.10 /Users/rik/tmp/test_dummy/venv/bin/python3.9 -m egse.confman.confman_cs start
-459800007 13825     1   0  4:31PM ttys003    0:02.97 /Users/rik/tmp/test_dummy/venv/bin/python3.9 -m cgse_dummy.dummy_sim start
+➜ cgse show procs
+                                                 Process Information                                                 
+┏━━━━━━━┳━━━━━━━━━━━━┳━━━━━━┳━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+┃ PID   ┃ Name       ┃ User ┃ CPU% ┃ Memory MB ┃ Status  ┃ Command                                                  ┃
+┡━━━━━━━╇━━━━━━━━━━━━╇━━━━━━╇━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
+│ 94461 │ python3.12 │ rik  │  0.0 │      46.9 │ running │ python -m cgse_dummy.dummy_sim start                     │
+│ 94554 │ python3.12 │ rik  │  0.0 │     124.1 │ running │ python -m cgse_dummy.dummy_cs start                      │
+│ 94360 │ python3.12 │ rik  │  0.0 │     121.3 │ running │ python -m egse.registry.server start --log-level WARNING │
+│ 94361 │ python3.12 │ rik  │  0.0 │      49.6 │ running │ python -m egse.logger.log_cs start                       │
+│ 94362 │ python3.12 │ rik  │  0.0 │      40.5 │ running │ python -m egse.notifyhub.server start                    │
+│ 94363 │ python3.12 │ rik  │  0.0 │     125.9 │ running │ python -m egse.storage.storage_cs start                  │
+│ 94364 │ python3.12 │ rik  │  0.0 │     126.1 │ running │ python -m egse.confman.confman_cs start                  │
+│ 94365 │ python3.12 │ rik  │  0.0 │     125.6 │ running │ python -m egse.procman.procman_cs start                  │
+└───────┴────────────┴──────┴──────┴───────────┴─────────┴──────────────────────────────────────────────────────────┘
 ```
 
 ## Register resources

{cgse-0.15.1 → cgse-0.16.0}/docs/dev_guide/uv.md

@@ -28,7 +28,7 @@ Python, but currently these have not been tested. So, we will for the moment sti
 3.9.20. Install this version as follows:
 
 ```shell
-$ uv python install 3.9.20
+$ uv python install 3.10
 ```
 
 !!! note "`pyenv`"
@@ -38,7 +38,7 @@ $ uv python install 3.9.20
     error. This is a known issue with `uv`.
 
     ```
-    pyenv: version `3.9.20' is not installed (set by /Users/rik/github/cgse/libs/cgse-common/.python-version)
+    pyenv: version `3.10.16' is not installed (set by /Users/rik/github/cgse/libs/cgse-common/.python-version)
     ```
 
 You can check which Python versions are installed already on your system:
@@ -67,7 +67,7 @@ You can check which Python versions are installed already on your system:
     You can pin a python version with the command:
 
     ```
-    $ uv python pin 3.9.20
+    $ uv python pin 3.10
     ```
 
     `uv` will search for a pinned version in the parent folders up to the root folder or your home directory.
@@ -83,7 +83,7 @@ When creating a virtual environment make sure you are in the root folder, e.g. `
 
 ```shell
 $ cd ~/github/cgse
-$ uv venv --python 3.9.20
+$ uv venv --python 3.10
 ```
 
 If you want to name your virtual environment, use the optional argument `--prompt <venv name>` in
@@ -103,7 +103,7 @@ with the command:
 
 ```shell
 $ uv pip list -v
-Using Python 3.9.20 environment at: /Users/rik/github/cgse/.venv
+Using Python 3.10.16 environment at: /Users/rik/github/cgse/.venv
 Package           Version     Editable project location
 ----------------- ----------- ---------------------------------------
 apscheduler       3.11.0

{cgse-0.15.1 → cgse-0.16.0}/docs/getting_started.md

@@ -2,19 +2,27 @@ All you need to get started using and building the CGSE.
 
 ## Requirements
 
-- Python 3.9.x (we do not yet support higher versions, but are working to extend the list)
+- Python 3.10.x (we do not yet support higher versions, but are working to extend the list)
 - macOS or Linux
 
 ## Virtual environment
 
 You should always work inside a virtual environment to somehow containerize your project such that it doesn't 
 pollute your global environment and you can run different projects next to each other. Create and activate a new 
-virtual environment as follows. It should be Python >= 3.9
+virtual environment as follows. It should be Python >= 3.10.
 
-```shell
-$ python -m venv venv
-$ source venv/bin/activate
-```
+=== "venv"
+
+    ```shell
+    $ python -m venv venv
+    $ source venv/bin/activate
+    ```
+
+=== "uv"
+
+    ```shell
+    $ uv venv --python 3.10
+    ```
 
 ## Installation
 
@@ -26,7 +34,7 @@ with the `cgse-common` which contains all common code that is generic and useful
 $ pip install cgse-common
 ```
 
-Check the [list of packages](./package_list.md) that are part of the CGSE repo and can be installed with `pip`. The 
+Check the [list of packages](./package_list.md) that are part of the CGSE monorepo and can be installed with `pip`. The 
 packages are described in more detail in the sections [Libs](./libs/index.md) and [Projects](./projects/index.md).
 
 ## Set up your environment
@@ -38,8 +46,8 @@ probably be higher and more lines will appear when other packages are installed.
 
 ```shell
 $ py -m egse.version
-CGSE version in Settings: 0.5.0
-Installed version for cgse-common= 0.5.0
+CGSE version in Settings: 0.15.1
+Installed version for cgse-common= 0.15.1
 ```
 
 Check your environment with the command below. This will probably print out some warning since you have not defined 

{cgse-0.15.1 → cgse-0.16.0}/docs/initialize.md

@@ -19,9 +19,9 @@ You should now have at least the follow three packages installed in your virtual
 
 ```text
 $ pip list | grep cgse
-cgse-common       0.5.0
-cgse-core         0.5.0
-cgse-tools        0.5.0
+cgse-common       0.15.1
+cgse-core         0.15.1
+cgse-tools        0.15.1
 ```
 
 ## The `cgse` command
@@ -61,9 +61,9 @@ version of the different components, use:
 
 ```text
 $ cgse version
-CGSE-COMMON installed version = 0.5.0 — Software framework to support hardware testing
-CGSE-CORE installed version = 0.5.0 — Core services for the CGSE framework
-CGSE-TOOLS installed version = 0.5.0 — Tools for CGSE
+CGSE-COMMON installed version = 0.15.1 — Software framework to support hardware testing
+CGSE-CORE installed version = 0.15.1 — Core services for the CGSE framework
+CGSE-TOOLS installed version = 0.15.1 — Tools for CGSE
 ```
 
 We will for now concentrate on the `init` command. This command will guide us through a number of

cgse-0.16.0/docs/package_list.md

@@ -0,0 +1,25 @@
+# Packages in the CGSE
+
+The CGSE is a monorepo and consists of numerous packages. Each of these packages are individually installable from 
+PyPI. We maintain a list here with all the packages in the monorepo.
+
+| Package                 | Description                                            | 
+|-------------------------|--------------------------------------------------------|
+| `cgse-common`           | The common code used by all other packages             |
+| `cgse-core`             | The core services                                      |
+| `cgse-coordinates`      | Coordinate reference Frames                            |
+| `cgse-gui`              | GUI components and styles (PyQt5)                      |
+| `cgse-tools`            | Plugin that adds functions to the `cgse` command       |
+| `symetrie-hexapod`      | Device drivers for the Symétrie Hexapods               |
+| `keithley-tempcontrol`  | Device driver for the Keithley temperature controller  |
+| `lakeshore-tempcontrol` | Device driver for the LakeShore temperature controller |
+| `plato-fits`            | FITS driver with PLATO specific format                 |
+| `plato-hdf5`            | HDF5 driver with PLATO specific format                 |
+| `plato-spw`             | SpaceWire driver with PATO specific packets            | 
+
+The following is a non-exhaustive list of known external packages that work well with the CGSE 
+in terms of commanding and monitoring.
+
+| Package       | Description                                                                                                           |
+|---------------|-----------------------------------------------------------------------------------------------------------------------|
+| `cgse-dummy`  | Provides a dummy device driver to demonstrate plugins, commands and how to develop an external package for the CGSE.  |

{cgse-0.15.1 → cgse-0.16.0}/libs/cgse-common/pyproject.toml

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

{cgse-0.15.1 → cgse-0.16.0}/libs/cgse-common/src/cgse_common/cgse.py

@@ -72,7 +72,7 @@ class SortedCommandGroup(TyperGroup):
         commands = super().list_commands(ctx)
 
         # Define priority commands in specific order
-        priority_commands = ["init", "version", "show", "top", "core", "registry", "log", "cm", "sm", "pm"]
+        priority_commands = ["init", "version", "show", "top", "core", "reg", "not", "log", "cm", "sm", "pm"]
 
         # Custom sort:
         # First the priority commands in the given order (their index)

cgse-0.16.0/libs/cgse-common/src/egse/connect.py

@@ -0,0 +1,369 @@
+import random
+import threading
+import time
+from enum import Enum
+
+from egse.log import logging
+
+logger = logging.getLogger("egse.connect")
+
+# random.seed(time.monotonic())  # uncomment for testing only, main application should set a seed.
+
+
+class ConnectionState(Enum):
+    DISCONNECTED = "disconnected"
+    CONNECTING = "connecting"
+    CONNECTED = "connected"
+    CIRCUIT_OPEN = "circuit_open"  # Temporarily stopped trying
+
+
+class BackoffStrategy(Enum):
+    """
+    Specifies the strategy for increasing the delay between retry attempts
+    in backoff algorithms to reduce load and avoid overwhelming services.
+
+    Strategies:
+        EXPONENTIAL:
+            The delay doubles with each retry attempt (e.g., 1s, 2s, 4s, 8s).
+            This is the most widely used approach because it quickly reduces load on struggling systems.
+        LINEAR:
+            The delay increases by a fixed amount each time (e.g., 1s, 2s, 3s, 4s).
+            This provides a more gradual reduction in request rate.
+        FIXED:
+            Uses the same delay between all retry attempts.
+            Simple but less adaptive to system conditions.
+
+    References:
+        - AWS Architecture Blog: Exponential Backoff And Jitter
+    """
+
+    EXPONENTIAL = "exponential"
+    """The delay doubles with each retry attempt (e.g., 1s, 2s, 4s, 8s). 
+    This is the most widely used approach because it quickly reduces load on struggling systems."""
+    LINEAR = "linear"
+    """The delay increases by a fixed amount each time (e.g., 1s, 2s, 3s, 4s). 
+    This provides a more gradual reduction in request rate."""
+    FIXED = "fixed"
+    """Uses the same delay between all retry attempts. Simple but less adaptive to system conditions."""
+
+
+class JitterStrategy(Enum):
+    """
+    Specifies the strategy for applying jitter (randomization) to retry intervals
+    in backoff algorithms to avoid synchronized retries and reduce load spikes.
+
+    Strategies:
+        NONE:
+            No jitter is applied. The retry interval is deterministic.
+        FULL:
+            Applies full jitter by selecting a random value uniformly between 0 and the calculated interval.
+            This maximizes randomness but can result in very short delays.
+        EQUAL:
+            Applies "equal jitter" as described in the AWS Architecture Blog.
+            The interval is randomized within [interval/2, interval], ensuring a minimum delay of half the interval.
+            Note: This is not the same as "a jitter of 50% around interval" (which would be [0.5 * interval, 1.5 * interval]).
+        PERCENT_10:
+            Applies a jitter of ±10% around the base interval, resulting in a random interval within [0.9 * interval, 1.1 * interval].
+
+    References:
+        - AWS Architecture Blog: Exponential Backoff And Jitter
+    """
+
+    NONE = "none"
+    """No jitter is applied to the backoff."""
+    FULL = "full"
+    """Maximum distribution but can be too random with very short intervals."""
+    EQUAL = "equal"
+    """Best balance, maintains backoff properties while preventing synchronization."""
+    PERCENT_10 = "10%"
+    """Add a jitter of 10% around the base interval."""
+
+
+def calculate_retry_interval(
+    attempt_number,
+    base_interval,
+    max_interval,
+    backoff_strategy: BackoffStrategy = BackoffStrategy.EXPONENTIAL,
+    jitter_strategy: JitterStrategy = JitterStrategy.EQUAL,
+):
+    """
+    Calculates the next retry interval based on the given backoff and jitter strategies.
+
+    Args:
+        attempt_number (int): The current retry attempt (starting from 0).
+        base_interval (float): The initial interval in seconds.
+        max_interval (float): The maximum allowed interval in seconds.
+        backoff_strategy (BackoffStrategy): Strategy for increasing the delay (exponential, linear, or fixed).
+        jitter_strategy (JitterStrategy): Strategy for randomizing the delay to avoid synchronization.
+
+    Returns:
+        float: The computed retry interval in seconds.
+
+    Notes:
+        - See the docstrings for BackoffStrategy and JitterStrategy for details on each strategy.
+        - Based on best practices from the AWS Architecture Blog: Exponential Backoff And Jitter.
+    """
+
+    if backoff_strategy == BackoffStrategy.EXPONENTIAL:
+        interval = min(base_interval * (2**attempt_number), max_interval)
+    elif backoff_strategy == BackoffStrategy.LINEAR:
+        interval = min(base_interval + attempt_number, max_interval)
+    else:
+        interval = base_interval
+
+    if jitter_strategy == JitterStrategy.NONE:
+        return interval
+    elif jitter_strategy == JitterStrategy.FULL:
+        return random.uniform(0, interval)
+    elif jitter_strategy == JitterStrategy.EQUAL:
+        return interval / 2 + random.uniform(0, interval / 2)
+    elif jitter_strategy == JitterStrategy.PERCENT_10:
+        jitter_amount = interval * 0.1
+        return interval + random.uniform(-jitter_amount, jitter_amount)
+
+    return interval
+
+
+class AsyncServiceConnector:
+    """
+    Asynchronous base class for robust service connection management with retry, backoff, and circuit breaker logic.
+
+    This class 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.
+
+    Features:
+        - Automatic retry with configurable backoff and jitter strategies.
+        - Circuit breaker to prevent repeated connection attempts after multiple failures.
+        - Connection state tracking (disconnected, connecting, connected, circuit open).
+
+    Usage:
+        1. Subclass `AsyncServiceConnector` and override the `connect_to_service()` coroutine with your
+           actual connection logic. Optionally, override `health_check()` for custom health verification.
+        2. Store the actual connection object (e.g., socket, transport) as an instance attribute in your subclass.
+        3. Use `attempt_connection()` to initiate connection attempts; it will handle retries and backoff automatically.
+        4. Use `is_connected()` to check connection status.
+
+    Example:
+        class MyConnector(AsyncServiceConnector):
+            async def connect_to_service(self):
+                self.connection = await create_socket()
+                return self.connection is not None
+
+            def get_connection(self):
+                return self.connection
+
+    Note:
+        The base class does not manage or expose the underlying connection object.
+        Your subclass should provide a method or property to access it as needed.
+    """
+
+    def __init__(self, service_name: str):
+        self.state = ConnectionState.DISCONNECTED
+        self.last_attempt = 0
+        self.base_interval = 1
+        self.retry_interval = 1  # Start with 1 second
+        self.max_retry_interval = 300  # Max 5 minutes
+        self.failure_count = 0
+        self.max_failures_before_circuit_break = 5
+        self.circuit_break_duration = 60  # 1 minute
+        self.circuit_opened_at = None
+
+        self.service_name = service_name
+
+    async def connect_to_service(self) -> bool:
+        logger.warning(
+            f"The connect_to_service() method is not implemented for {self.service_name}, connection will always fail."
+        )
+        return False
+
+    async def health_check(self) -> bool:
+        logger.warning(
+            f"The health_check() method is not implemented for {self.service_name}, check will always return false."
+        )
+        return False
+
+    def should_attempt_connection(self) -> bool:
+        """Return True if we should attempt a new connection."""
+        now = time.monotonic()
+
+        # If circuit is open, check if we should close it
+        if self.state == ConnectionState.CIRCUIT_OPEN:
+            if now - self.circuit_opened_at > self.circuit_break_duration:
+                self.state = ConnectionState.DISCONNECTED
+                self.failure_count = 0
+                self.retry_interval = 1
+                return True
+            return False
+
+        # Regular backoff logic
+        return now - self.last_attempt >= self.retry_interval
+
+    async def attempt_connection(self):
+        """Try to connect to the service.
+
+        This will execute the callable argument `connect_to_service` that was passed
+        into the constructor. That function shall return True when the connection
+        succeeded, False otherwise.
+        """
+        if not self.should_attempt_connection():
+            return
+
+        self.state = ConnectionState.CONNECTING
+        self.last_attempt = time.monotonic()
+
+        try:
+            success = await self.connect_to_service()
+
+            if success:
+                self.state = ConnectionState.CONNECTED
+                self.failure_count = 0
+                self.retry_interval = 1  # Reset backoff
+                logger.info(f"Successfully connected to service {self.service_name}")
+            else:
+                # warning should have been logged by the connect_to_service() callable.
+                self.handle_connection_failure()
+
+        except Exception as exc:
+            logger.warning(f"Failed to connect to service {self.service_name}: {exc}")
+            self.handle_connection_failure()
+
+    def handle_connection_failure(self):
+        self.failure_count += 1
+
+        # Open circuit breaker if too many failures
+        if self.failure_count >= self.max_failures_before_circuit_break:
+            self.state = ConnectionState.CIRCUIT_OPEN
+            self.circuit_opened_at = time.time()
+            logger.warning(
+                f"Circuit breaker opened for service {self.service_name} after {self.failure_count} failures"
+            )
+        else:
+            self.state = ConnectionState.DISCONNECTED
+            self.retry_interval = calculate_retry_interval(
+                self.failure_count,
+                self.base_interval,
+                self.max_retry_interval,
+                BackoffStrategy.EXPONENTIAL,
+                JitterStrategy.EQUAL,
+            )
+            logger.debug(f"retry_interval={self.retry_interval}")
+
+    def is_connected(self) -> bool:
+        return self.state == ConnectionState.CONNECTED
+
+
+class ServiceConnector:
+    """
+    Synchronous base class for robust service connection management with retry, backoff, and circuit breaker logic.
+
+    This class 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.
+
+    Features:
+        - Automatic retry with configurable backoff and jitter strategies.
+        - Circuit breaker to prevent repeated connection attempts after multiple failures.
+        - Connection state tracking (disconnected, connecting, connected, circuit open).
+        - Thread-safe operation using a lock for all state changes.
+
+    Usage:
+        1. Subclass `ServiceConnector` and override the `connect_to_service()` method with your
+           actual connection logic. Optionally, override `health_check()` for custom health verification.
+        2. Store the actual connection object (e.g., socket, transport) as an instance attribute in your subclass.
+        3. Use `attempt_connection()` to initiate connection attempts; it will handle retries and backoff automatically.
+        4. Use `is_connected()` to check connection status.
+
+    Example:
+        class MyConnector(ServiceConnector):
+            def connect_to_service(self):
+                self.connection = create_socket()
+                return self.connection is not None
+
+            def get_connection(self):
+                return self.connection
+
+    Note:
+        The base class does not manage or expose the underlying connection object.
+        Your subclass should provide a method or property to access it as needed.
+    """
+
+    def __init__(self, service_name: str):
+        self.state = ConnectionState.DISCONNECTED
+        self.last_attempt = 0
+        self.base_interval = 1
+        self.retry_interval = 1
+        self.max_retry_interval = 300
+        self.failure_count = 0
+        self.max_failures_before_circuit_break = 5
+        self.circuit_break_duration = 60
+        self.circuit_opened_at = None
+        self.service_name = service_name
+        self._lock = threading.RLock()
+
+    def connect_to_service(self) -> bool:
+        logger.warning(
+            f"The connect_to_service() method is not implemented for {self.service_name}, connection will always fail."
+        )
+        return False
+
+    def health_check(self) -> bool:
+        logger.warning(
+            f"The health_check() method is not implemented for {self.service_name}, check will always return false."
+        )
+        return False
+
+    def should_attempt_connection(self) -> bool:
+        now = time.monotonic()
+        with self._lock:
+            if self.state == ConnectionState.CIRCUIT_OPEN:
+                if now - self.circuit_opened_at > self.circuit_break_duration:
+                    self.state = ConnectionState.DISCONNECTED
+                    self.failure_count = 0
+                    self.retry_interval = 1
+                    return True
+                return False
+            return now - self.last_attempt >= self.retry_interval
+
+    def attempt_connection(self):
+        with self._lock:
+            if not self.should_attempt_connection():
+                return
+            self.state = ConnectionState.CONNECTING
+            self.last_attempt = time.monotonic()
+
+        try:
+            success = self.connect_to_service()
+            with self._lock:
+                if success:
+                    self.state = ConnectionState.CONNECTED
+                    self.failure_count = 0
+                    self.retry_interval = 1
+                    logger.info(f"Successfully connected to service {self.service_name}")
+                else:
+                    self.handle_connection_failure()
+        except Exception as exc:
+            logger.error(f"Failed to connect to service {self.service_name}: {exc}")
+            with self._lock:
+                self.handle_connection_failure()
+
+    def handle_connection_failure(self):
+        self.failure_count += 1
+        if self.failure_count >= self.max_failures_before_circuit_break:
+            self.state = ConnectionState.CIRCUIT_OPEN
+            self.circuit_opened_at = time.monotonic()
+            logger.warning(
+                f"Circuit breaker opened for service {self.service_name} after {self.failure_count} failures"
+            )
+        else:
+            self.state = ConnectionState.DISCONNECTED
+            self.retry_interval = calculate_retry_interval(
+                self.failure_count,
+                self.base_interval,
+                self.max_retry_interval,
+                BackoffStrategy.EXPONENTIAL,
+                JitterStrategy.EQUAL,
+            )
+            logger.debug(f"retry_interval={self.retry_interval}")
+
+    def is_connected(self) -> bool:
+        with self._lock:
+            return self.state == ConnectionState.CONNECTED

{cgse-0.15.1 → cgse-0.16.0}/libs/cgse-common/src/egse/env.py

@@ -451,7 +451,7 @@ def set_local_settings(path: str | Path | None):
     _env.set("LOCAL_SETTINGS", path)
 
 
-def get_local_settings_path() -> str or None:
+def get_local_settings_path() -> str | None:
     """
     Returns the fully qualified filename of the local settings YAML file. When the local settings environment
     variable is not defined or is an empty string, None is returned.

{cgse-0.15.1 → cgse-0.16.0}/libs/cgse-common/src/egse/system.py

@@ -2298,13 +2298,13 @@ def caffeinate(pid: int = None):
 
     See Also:
         macOS caffeinate(8) man page for more details on the underlying utility.
- """
+    """
     if not pid:
         pid = os.getpid()
 
     if get_os_name() == "macos":
         logger.warning(f"Running 'caffeinate -i -w {pid}' on macOS to prevent the system from idle sleeping.")
-        subprocess.Popen([shutil.which('caffeinate'), "-i", "-w", str(pid)])
+        subprocess.Popen([shutil.which("caffeinate"), "-i", "-w", str(pid)])
 
 
 ignore_m_warning("egse.system")