cgse 0.17.2__tar.gz → 0.17.3__tar.gz

{cgse-0.17.2 → cgse-0.17.3}/CHANGELOG.md

@@ -9,6 +9,11 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 ## [Unreleased]
 
 
+## [0.17.3] - 2025-11-29
+
+In the previous release, uncommitted and untracked files were released by mistake. This release fixes this. Nothings has been changed with respect of release 0.17.2, except the removal of the uncommitted and untracked files.
+
+
 ## [0.17.2] - 2025-11-28
 
 This release is mainly on maintenance and improvements to the `cgse-common` package. 

{cgse-0.17.2 → cgse-0.17.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgse
-Version: 0.17.2
+Version: 0.17.3
 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.17.2 → cgse-0.17.3}/libs/cgse-common/pyproject.toml

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

{cgse-0.17.2 → cgse-0.17.3}/libs/cgse-common/src/egse/device.py

@@ -339,76 +339,6 @@ 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.

{cgse-0.17.2 → cgse-0.17.3}/libs/cgse-common/src/egse/scpi.py

@@ -4,23 +4,17 @@ 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
 IDENTIFICATION_QUERY = "*IDN?"
 
-VERBOSE_DEBUG = bool_env("VERBOSE_DEBUG")
-
-SEPARATOR = b"\n"
-SEPARATOR_STR = SEPARATOR.decode()
-
 
 class SCPICommand:
     """Base class for SCPI commands."""
@@ -38,7 +32,7 @@ class SCPICommand:
         raise NotImplementedError("Subclasses must implement get_cmd_string().")
 
 
-class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
+class AsyncSCPIInterface(AsyncDeviceTransport):
     """Generic asynchronous interface for devices that use SCPI commands over Ethernet."""
 
     def __init__(
@@ -62,9 +56,7 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
             read_timeout: Timeout for read operations in seconds
             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 {}
@@ -78,66 +70,8 @@ class AsyncSCPIInterface(AsyncDeviceInterface, 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."""
-
-    def is_simulator(self) -> bool:
-        return 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
-        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
+        """Prevents multiple coroutines from attempting to read, write or query from the same stream
+        at the same time."""
 
     async def connect(self) -> None:
         """Connect to the device asynchronously.
@@ -150,51 +84,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
 
-                response = await self.read_string()
-                if VERBOSE_DEBUG:
-                    logger.debug(f"Response after connection: {response}")
-
-                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.
@@ -205,20 +135,22 @@ 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."""
-        await self.disconnect()
-        await asyncio.sleep(0.1)
-        await self.connect()
+        async with self._connect_lock:
+            if self._is_connection_open:
+                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.
@@ -236,7 +168,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()
@@ -245,7 +177,8 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
             return True
 
         except DeviceError as exc:
-            logger.error(f"{self._device_name}: Connection test failed: {exc}", exc_info=True)
+            logger.exception(exc)
+            logger.error(f"{self.device_name}: Connection test failed")
             await self.disconnect()
             return False
 
@@ -262,20 +195,19 @@ 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 the proper separator or terminator
-                if not command.endswith(SEPARATOR_STR):
-                    command += SEPARATOR_STR
+                # Ensure command ends with newline
+                if not command.endswith("\n"):
+                    command += "\n"
 
-                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:
         """
@@ -290,7 +222,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
@@ -299,19 +231,18 @@ class AsyncSCPIInterface(AsyncDeviceInterface, AsyncDeviceTransport):
                 # Try to read until newline (common SCPI terminator)
                 try:
                     response = await asyncio.wait_for(
-                        self._reader.readuntil(separator=SEPARATOR), timeout=self.read_timeout
+                        self._reader.readuntil(separator=b"\n"), 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 SEPARATOR
+                    logger.warning(f"{self.device_name}: Incomplete read, got {len(exc.partial)} bytes")
+                    return exc.partial if exc.partial else b"\r\n"
 
                 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
@@ -319,9 +250,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:
         """
@@ -342,35 +273,33 @@ 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 the required terminator
-                if not command.endswith(SEPARATOR_STR):
-                    command += SEPARATOR_STR
+                # Ensure command ends with newline
+                if not command.endswith("\n"):
+                    command += "\n"
 
-                logger.info(f"-----> {command=}")
                 self._writer.write(command.encode())
                 await self._writer.drain()
 
-                # First, small delay to allow the device to prepare a response
+                # First, small delay to allow device to prepare response
                 await asyncio.sleep(0.01)
 
-                # Try to read until the required separator (common SCPI terminator)
+                # Try to read until newline (common SCPI terminator)
                 try:
                     response = await asyncio.wait_for(
-                        self._reader.readuntil(separator=SEPARATOR), timeout=self.read_timeout
+                        self._reader.readuntil(separator=b"\n"), 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 SEPARATOR
+                    logger.warning(f"{self.device_name}: Incomplete read, got {len(exc.partial)} bytes")
+                    return exc.partial if exc.partial else b"\r\n"
 
                 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
@@ -378,11 +307,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."""

{cgse-0.17.2 → cgse-0.17.3}/libs/cgse-coordinates/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-coordinates"
-version = "0.17.2"
+version = "0.17.3"
 description = "Reference Frames and Coordinate Transofrmations for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.17.2 → cgse-0.17.3}/libs/cgse-core/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-core"
-version = "0.17.2"
+version = "0.17.3"
 description = "Core services for the CGSE framework"
 authors = [
     {name = "IvS KU Leuven"}

cgse-0.17.3/libs/cgse-core/src/egse/connect.py

@@ -0,0 +1,55 @@
+from egse.env import bool_env
+from egse.log import logging
+from egse.zmq_ser import connect_address
+
+logger = logging.getLogger("egse.connect")
+
+# random.seed(time.monotonic())  # uncomment for testing only, main application should set a seed.
+
+VERBOSE_DEBUG = bool_env("VERBOSE_DEBUG")
+
+
+def get_endpoint(
+    service_type: str,
+    protocol: str = "tcp",
+    hostname: str = "localhost",
+    port: int = 0,
+):
+    """
+    Returns the endpoint for a service, either from the registry or by constructing
+    it from protocol, hostname and port.
+
+    If port is 0 (the default), attempt to retrieve the endpoint from the service registry.
+
+    Args:
+        service_type: The service type to look up in the registry.
+        protocol: Protocol to use if constructing the endpoint, defaults to tcp.
+        hostname: Hostname to use if constructing the endpoint, defaults to localhost.
+        port: Port to use if constructing the endpoint, defaults to 0.
+
+    Returns:
+        The endpoint string.
+
+    Raises:
+        RuntimeError: If no endpoint can be determined.
+    """
+    endpoint = None
+    from egse.registry.client import RegistryClient
+
+    if port == 0:
+        with RegistryClient() as reg:
+            endpoint = reg.get_endpoint(service_type)
+        if endpoint:
+            if VERBOSE_DEBUG:
+                logger.debug(f"Endpoint for {service_type} found in registry: {endpoint}")
+        else:
+            logger.warning(f"No endpoint for {service_type} found in registry.")
+
+    if not endpoint:
+        if port == 0:
+            raise RuntimeError(f"No service registered as {service_type} and no port provided.")
+        endpoint = connect_address(protocol, hostname, port)
+        if VERBOSE_DEBUG:
+            logger.debug(f"Endpoint constructed from protocol/hostname/port: {endpoint}")
+
+    return endpoint

{cgse-0.17.2 → cgse-0.17.3}/libs/cgse-core/src/egse/dummy.py

@@ -35,7 +35,6 @@ and stopped with:
 
 from __future__ import annotations
 
-import contextlib
 import multiprocessing
 import random
 import select
@@ -53,14 +52,12 @@ from egse.device import DeviceConnectionError
 from egse.device import DeviceConnectionInterface
 from egse.device import DeviceTimeoutError
 from egse.device import DeviceTransport
-from egse.env import bool_env
 from egse.log import logger
 from egse.protocol import CommandProtocol
 from egse.proxy import Proxy
 from egse.system import SignalCatcher
 from egse.system import attrdict
 from egse.system import format_datetime
-from egse.system import type_name
 from egse.zmq_ser import bind_address
 from egse.zmq_ser import connect_address
 
@@ -80,9 +77,6 @@ WRITE_TIMEOUT = 1.0
 CONNECT_TIMEOUT = 3.0
 """The maximum time in seconds to wait for establishing a socket connect."""
 
-
-VERBOSE_DEBUG = bool_env("VERBOSE_DEBUG", default=False)
-
 # Especially DummyCommand and DummyController need to be defined in a known module
 # because those objects are pickled and when de-pickled at the clients side the class
 # definition must be known.
@@ -122,17 +116,14 @@ def is_dummy_cs_active() -> bool:
 
 
 def is_dummy_dev_active() -> bool:
-    if VERBOSE_DEBUG:
-        logger.debug("Checking if dummy device is active...")
     try:
         dev = DummyDeviceEthernetInterface(DEV_HOST, DEV_PORT)
         dev.connect()
         rc = dev.trans("ping\n")
         dev.disconnect()
         return rc.decode().strip() == "pong"
-    except (DeviceConnectionError, ConnectionResetError, DeviceTimeoutError) as exc:
-        if VERBOSE_DEBUG:
-            logger.debug(f"Caught {type_name(exc)}: {exc} - returning False")
+    except DeviceConnectionError as exc:
+        # logger.error(f"Caught {type_name(exc)}: {exc}")
         return False
 
 
@@ -589,18 +580,11 @@ def start_dev():
         with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
             s.bind((DEV_HOST, DEV_PORT))
             s.listen()
-            s.settimeout(CONNECT_TIMEOUT)
             logger.info(f"Ready to accept connection on {DEV_HOST}:{DEV_PORT}...")
-            while True:
-                with contextlib.suppress(socket.timeout):
-                    conn, addr = s.accept()
-                    break
-                if killer.term_signal_received:
-                    return
+            conn, addr = s.accept()
             with conn:
                 logger.info(f"Accepted connection from {addr}")
                 conn.sendall(f"Dummy Device {__version__}".encode())
-                conn.settimeout(READ_TIMEOUT)
                 try:
                     while True:
                         error_msg = ""

{cgse-0.17.2 → cgse-0.17.3}/libs/cgse-core/src/egse/logger/__init__.py

@@ -57,7 +57,7 @@ COMMANDER_PORT = settings.get("COMMANDER_PORT", 0)  # dynamically assigned by th
 _initialised = False  # will be set to True in the setup_logging() function
 
 
-def get_log_file_name() -> str:
+def get_log_file_name():
     """
     Returns the filename of the log file as defined in the Settings or return the default name 'general.log'.
     """
@@ -315,7 +315,7 @@ def send_request(command_request: str):
     """Sends a request to the Logger Control Server and waits for a response."""
 
     if COMMANDER_PORT == 0:
-        endpoint = get_endpoint_from_registry(SERVICE_TYPE)
+        endpoint = get_endpoint_from_registry()
     else:
         endpoint = f"{PROTOCOL}://{HOSTNAME}:{COMMANDER_PORT}"
 

{cgse-0.17.2 → cgse-0.17.3}/libs/cgse-core/src/egse/notifyhub/server.py

@@ -23,12 +23,10 @@ from egse.notifyhub import SERVICE_TYPE
 from egse.notifyhub import STATS_INTERVAL
 from egse.notifyhub.client import AsyncNotificationHubClient
 from egse.registry import MessageType
-from egse.registry.client import REQUEST_TIMEOUT
-from egse.registry.client import AsyncRegistryClient
+from egse.registry.client import AsyncRegistryClient, REQUEST_TIMEOUT
 from egse.system import TyperAsyncCommand
 from egse.system import get_host_ip
 from egse.zmq_ser import get_port_number
-
 from .event import NotificationEvent
 
 REQUEST_POLL_TIMEOUT = 1.0