cgse 0.16.8__tar.gz → 0.16.10__tar.gz

{cgse-0.16.8 → cgse-0.16.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgse
-Version: 0.16.8
+Version: 0.16.10
 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.16.8 → cgse-0.16.10}/docs/libs/cgse-common/settings.md

@@ -39,8 +39,8 @@ Settings
 │   ├── METRICS_PORT: 7003
 │   ├── MAX_NR_LOG_FILES: 20
 │   ├── MAX_SIZE_LOG_FILES: 20
-│   ├── TEXTUALOG_IP_ADDRESS: 127.0.0.1
-│   └── TEXTUALOG_LISTENING_PORT: 19996
+│   ├── EXTERN_LOG_HOST: 127.0.0.1
+│   └── EXTERN_LOG_PORT: 19996
 ├── Configuration Manager Control Server
 │   ├── PROTOCOL: tcp
 │   ├── HOSTNAME: localhost
@@ -146,8 +146,8 @@ Logging Control Server:                          # LOG_CS
     METRICS_PORT:                  7003          # The HTTP port where Prometheus will connect to for retrieving metrics
     MAX_NR_LOG_FILES:                20          # The maximum number of log files that will be maintained in a roll-over
     MAX_SIZE_LOG_FILES:              20          # The maximum size one log file can become
-    TEXTUALOG_IP_ADDRESS:     127.0.0.1          # The IP address of the textualog listening server
-    TEXTUALOG_LISTENING_PORT:     19996          # The port number on which the textualog server is listening
+    EXTERN_LOG_HOST:          127.0.0.1          # The IP address of the external logger 
+    EXTERN_LOG_PORT:              19996          # The port number on which the external logger is listening
 
 Configuration Manager Control Server:            # CM_CS
 

{cgse-0.16.8 → cgse-0.16.10}/libs/cgse-common/pyproject.toml

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

{cgse-0.16.8 → cgse-0.16.10}/libs/cgse-coordinates/pyproject.toml

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

{cgse-0.16.8 → cgse-0.16.10}/libs/cgse-core/pyproject.toml

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

{cgse-0.16.8 → cgse-0.16.10}/libs/cgse-core/src/cgse_core/settings.yaml

@@ -18,8 +18,8 @@ Logging Control Server:                          # LOG_CS
     MAX_SIZE_LOG_FILES:              20          # The maximum size one log file can become
     RECEIVER_PORT:                 6105
     COMMANDER_PORT:                6106
-    TEXTUALOG_IP_ADDRESS:     127.0.0.1          # The IP address of the textualog listening server
-    TEXTUALOG_LISTENING_PORT:     19996          # The port number on which the textualog server is listening
+    EXTERN_LOG_HOST:          127.0.0.1          # The IP address of the external logger
+    EXTERN_LOG_PORT:             19996          # The port number on which the external logger is listening
 
 Configuration Manager Control Server:            # CM_CS
 

{cgse-0.16.8 → cgse-0.16.10}/libs/cgse-core/src/egse/logger/__init__.py

@@ -35,6 +35,7 @@ import zmq
 from egse.log import LOG_FORMAT_FULL
 from egse.log import PackageFilter
 from egse.log import egse_logger
+from egse.log import get_log_level_from_env
 from egse.log import logger
 from egse.log import root_logger
 from egse.registry.client import RegistryClient
@@ -201,7 +202,7 @@ def setup_logging():
 
     logging.disable(logging.NOTSET)
     for handler in root_logger.handlers:
-        handler.setLevel(logging.INFO)
+        handler.setLevel(get_log_level_from_env())
 
     egse_logger.setLevel(logging.DEBUG)
 

{cgse-0.16.8 → cgse-0.16.10}/libs/cgse-core/src/egse/logger/log_cs.py

@@ -144,9 +144,9 @@ def start():
     stream_handler.setFormatter(stream_formatter)
     stream_handler.addFilter(PackageFilter())
 
-    # Log records are also sent to the textualog listening server
+    # Log records are also sent to the external logger
 
-    socket_handler = SocketHandler(CTRL_SETTINGS.TEXTUALOG_IP_ADDRESS, CTRL_SETTINGS.TEXTUALOG_LISTENING_PORT)
+    socket_handler = SocketHandler(CTRL_SETTINGS.EXTERN_LOG_HOST, CTRL_SETTINGS.EXTERN_LOG_PORT)
     socket_handler.addFilter(PackageFilter())
     socket_handler.setFormatter(file_formatter)
 

{cgse-0.16.8 → cgse-0.16.10}/libs/cgse-core/src/egse/registry/client.py

@@ -114,8 +114,9 @@ class RegistryClient:
         self.poller.register(self.sub_socket, zmq.POLLIN)
 
     def _connect_hb_socket(self):
-        self.hb_socket = self.context.socket(zmq.REQ)
+        self.hb_socket = self.context.socket(zmq.DEALER)
         self.hb_socket.setsockopt(zmq.LINGER, 0)  # Don't wait for unsent messages on close()
+        self.hb_socket.setsockopt(zmq.IDENTITY, self._client_id)
         self.hb_socket.connect(self.registry_hb_endpoint)
 
     def disconnect(self):
@@ -214,9 +215,6 @@ class RegistryClient:
                 return response
             else:
                 self.logger.error(f"Request timed out after {HEART_BEAT_TIMEOUT:.2f}s")
-                self._disconnect_hb_socket()
-                time.sleep(HEART_BEAT_RECONNECT)
-                self._connect_hb_socket()
                 return {"success": False, "error": "Request timed out"}
 
         except zmq.ZMQError as exc:
@@ -329,7 +327,7 @@ class RegistryClient:
             metadata=self._service_info["metadata"],
         )
 
-    def discover_service(self, service_type: str, use_cache: bool = False) -> dict[str, Any] | None:
+    def discover_service(self, service_type: str) -> dict[str, Any] | None:
         """
         Discover a service of the specified type. The service is guaranteed to be healthy at the time of discovery.
 
@@ -341,15 +339,10 @@ class RegistryClient:
 
         Args:
             service_type: Type of service to discover
-            use_cache: Whether to use cached service information
 
         Returns:
             Service information if found, None otherwise
         """
-        # Try to use cache first if enabled
-        if use_cache:
-            self.logger.info("Cache not yet implemented.")
-
         request = {"action": "discover", "service_type": service_type}
 
         response = self._send_request(MessageType.REQUEST_WITH_REPLY, request)
@@ -363,14 +356,13 @@ class RegistryClient:
             self.logger.warning(f"Service discovery failed: {response.get('error')}")
             return None
 
-    def get_service(self, service_id: str | None = None, use_cache: bool = True) -> dict[str, Any] | None:
+    def get_service(self, service_id: str | None = None) -> dict[str, Any] | None:
         """
         Get information about a specific service. When no service_id is given,
         the service_id known to this client will be used.
 
         Args:
             service_id: ID of the service to get [default=None]
-            use_cache: Whether to use cached service information
 
         Returns:
             Service information if found, None otherwise.
@@ -479,14 +471,14 @@ class RegistryClient:
 
                     # Do a health check
                     if not self.health_check():
-                        self.logger.warning("ServiceRegistry not responding.")
+                        self.logger.warning("Heartbeat failed: ServiceRegistry not responding.")
                         return
                     else:
-                        self.logger.info("Health check succeeded, reregistering...")
+                        self.logger.info("Heartbeat failed, but health check succeeded, reregistering...")
                         self.reregister()
 
                 else:
-                    self.logger.debug(response.get("message"))
+                    self.logger.debug(f"Heartbeat succeeded: {response.get('message')}")
 
             except Exception as exc:
                 self.logger.error(f"Error sending heartbeat: {exc}")
@@ -582,10 +574,6 @@ class AsyncRegistryClient:
 
         self._event_handlers = {}
 
-        # Service cache (for discovery)
-        self._service_cache = {}
-        self._service_cache_lock = None
-
         self.req_socket: zmq.asyncio.Socket | None = None
         self.sub_socket: zmq.asyncio.Socket | None = None
         self.hb_socket: zmq.asyncio.Socket | None = None
@@ -613,8 +601,9 @@ class AsyncRegistryClient:
         self.sub_socket.setsockopt_string(zmq.SUBSCRIBE, "")
 
     def _connect_hb_socket(self):
-        self.hb_socket = self.context.socket(zmq.REQ)
+        self.hb_socket = self.context.socket(zmq.DEALER)
         self.hb_socket.setsockopt(zmq.LINGER, 0)  # Don't wait for unsent messages on close()
+        self.hb_socket.setsockopt(zmq.IDENTITY, self._client_id)
         self.hb_socket.connect(self.registry_hb_endpoint)
 
     def disconnect(self):
@@ -634,11 +623,6 @@ class AsyncRegistryClient:
             self.hb_socket.close()
         self.hb_socket = None
 
-    def _get_service_cache_lock(self):
-        if self._service_cache_lock is None:
-            self._service_cache_lock = asyncio.Lock()
-        return self._service_cache_lock
-
     async def _send_request(
         self, msg_type: MessageType, request: dict[str, Any], timeout: float = None
     ) -> dict[str, Any]:
@@ -713,11 +697,8 @@ class AsyncRegistryClient:
                 return response
             except asyncio.TimeoutError:
                 self.logger.error(f"Heartbeat request timed out after {HEART_BEAT_TIMEOUT:.2f}s")
-                # Reset the socket to avoid invalid state
-                self._disconnect_hb_socket()
-                await asyncio.sleep(HEART_BEAT_RECONNECT)
-                self._connect_hb_socket()
                 return {"success": False, "error": "Heartbeat request timed out"}
+
         except zmq.ZMQError as exc:
             self.logger.error(f"ZMQ error: {exc}", exc_info=True)
             return {"success": False, "error": str(exc)}
@@ -873,14 +854,14 @@ class AsyncRegistryClient:
 
                             # Do a health check
                             if not await self.health_check():
-                                self.logger.warning("ServiceRegistry not responding.")
+                                self.logger.warning("Heartbeat failed: ServiceRegistry not responding.")
                                 continue
                             else:
-                                self.logger.info("Health check succeeded, reregistering...")
+                                self.logger.info("Heartbeat failed, but health check succeeded, reregistering...")
                                 await self.reregister()
 
                         else:
-                            self.logger.debug(response.get("message"))
+                            self.logger.debug(f"Heartbeat succeeded: {response.get('message')}")
                     except Exception as exc:
                         self.logger.error(f"Error in heartbeat loop: {exc}", exc_info=True)
 
@@ -992,9 +973,6 @@ class AsyncRegistryClient:
 
                         self.logger.debug(f"Received event: {event_type}")
 
-                        # Update service cache based on events
-                        await self._update_cache_from_event(event_type, event)
-
                         # Call registered handlers
                         handlers = self._event_handlers.get(event_type, [])
                         for handler in handlers:
@@ -1022,30 +1000,7 @@ class AsyncRegistryClient:
         self.logger.info("Started event listener task")
         return task
 
-    async def _update_cache_from_event(self, event_type: str, event: dict[str, Any]) -> None:
-        """
-        Update the service cache based on registry events.
-
-        Args:
-            event_type: Type of the event.
-            event: Event data
-        """
-        async with self._get_service_cache_lock():
-            data = event.get("data", {})
-            service_id = data.get("service_id")
-
-            if not service_id:
-                return
-
-            if event_type == "register":
-                service_info = data.get("service_info", {})
-                if service_info:
-                    self._service_cache[service_id] = service_info
-            elif event_type in ("deregister", "expire"):
-                if service_id in self._service_cache:
-                    del self._service_cache[service_id]
-
-    async def discover_service(self, service_type: str, use_cache: bool = True) -> dict[str, Any] | None:
+    async def discover_service(self, service_type: str) -> dict[str, Any] | None:
         """
         Discover a service of the specified type. The service is guaranteed to be healthy at the time of discovery.
 
@@ -1057,27 +1012,11 @@ class AsyncRegistryClient:
 
         Args:
             service_type: Type of service to discover
-            use_cache: Whether to use cached service information
 
         Returns:
             Service information if found, None otherwise
         """
-        # Try to use cache first if enabled
-        if use_cache:
-            async with self._get_service_cache_lock():
-                # Find services of the specified type
-                matching_services = []
-                for service_id, service_info in self._service_cache.items():
-                    if service_info.get("type") == service_type or service_type in service_info.get("tags", []):
-                        matching_services.append(service_info)
-
-                if matching_services:
-                    # Simple load balancing - random selection
-                    import random
-
-                    return random.choice(matching_services)
-
-        # If not found in cache or cache disabled, ask the registry
+
         request = {"action": "discover", "service_type": service_type}
 
         response = await self._send_request(MessageType.REQUEST_WITH_REPLY, request)
@@ -1087,34 +1026,25 @@ class AsyncRegistryClient:
         if response.get("success"):
             service = response.get("service")
 
-            # Update cache
-            if service and "id" in service:
-                async with self._get_service_cache_lock():
-                    self._service_cache[service["id"]] = service
-
             return service
         else:
             self.logger.warning(f"Service discovery failed: {response.get('error')}")
             return None
 
-    async def get_service(self, service_id: str, use_cache: bool = True) -> dict[str, Any] | None:
+    async def get_service(self, service_id: str | None = None) -> dict[str, Any] | None:
         """
-        Get information about a specific service.
+        Get information about a specific service.  When no service_id is given,
+        the service_id known to this client will be used.
 
         Args:
             service_id: ID of the service to get
-            use_cache: Whether to use cached service information
 
         Returns:
             Service information if found, None otherwise
         """
-        # Try to use cache first if enabled
-        if use_cache:
-            async with self._get_service_cache_lock():
-                if service_id in self._service_cache:
-                    return self._service_cache[service_id]
 
-        # If not found in cache or cache disabled, ask the registry
+        service_id = service_id or self._service_id
+
         request = {"action": "get", "service_id": service_id}
 
         response = await self._send_request(MessageType.REQUEST_WITH_REPLY, request)
@@ -1122,11 +1052,6 @@ class AsyncRegistryClient:
         if response.get("success"):
             service = response.get("service")
 
-            # Update cache
-            if service:
-                async with self._get_service_cache_lock():
-                    self._service_cache[service_id] = service
-
             return service
         else:
             self.logger.warning(f"Get service failed: {response.get('error')}")
@@ -1149,12 +1074,6 @@ class AsyncRegistryClient:
         if response.get("success"):
             services = response.get("services", [])
 
-            # Update cache
-            async with self._get_service_cache_lock():
-                for service in services:
-                    if "id" in service:
-                        self._service_cache[service["id"]] = service
-
             return services
         else:
             self.logger.warning(f"List services failed: {response.get('error')}")
@@ -1224,35 +1143,6 @@ class AsyncRegistryClient:
         except Exception as exc:
             self.logger.error(f"Error during cleanup: {exc}")
 
-    @asynccontextmanager
-    async def register_context(self, *args, **kwargs):
-        """
-        Async context manager for service registration.
-
-        Example:
-            async with client.register_context("my-service", "localhost", 8080):
-                # Service is registered
-                await app.start()
-            # Service is automatically deregistered
-        """
-        service_id = await self.register(*args, **kwargs)
-
-        if not service_id:
-            raise RuntimeError("Failed to register service")
-
-        # Start heartbeat and event listener
-        await self.start_heartbeat()
-        await self.start_event_listener()
-
-        try:
-            yield service_id
-        finally:
-            # Clean up
-            await self.stop_event_listener()
-            await self.stop_heartbeat()
-            await self.deregister()
-            # await self.close()  # client shall not be closed by this context manager !!
-
 
 def is_service_registered(service_type: str):
     """Convenience function to check if a service is registered."""

{cgse-0.16.8 → cgse-0.16.10}/libs/cgse-core/src/egse/registry/server.py

@@ -101,19 +101,19 @@ class AsyncRegistryServer:
         req_rep_endpoint = f"tcp://*:{self.req_port}"
         self.req_socket = self.context.socket(zmq.ROUTER)
         self.req_socket.bind(req_rep_endpoint)
-        self.logger.info(f"Binding request socket to {req_rep_endpoint}")
+        self.logger.debug(f"Binding request ROUTER socket to {req_rep_endpoint}")
 
         # Socket to publish service events
         pub_endpoint = f"tcp://*:{self.pub_port}"
         self.pub_socket = self.context.socket(zmq.PUB)
         self.pub_socket.bind(pub_endpoint)
-        self.logger.info(f"Binding publish socket to {pub_endpoint}")
+        self.logger.debug(f"Binding publish PUB socket to {pub_endpoint}")
 
         # Socket to handle heartbeats
         hb_endpoint = f"tcp://*:{self.hb_port}"
-        self.hb_socket = self.context.socket(zmq.REP)
+        self.hb_socket = self.context.socket(zmq.ROUTER)
         self.hb_socket.bind(hb_endpoint)
-        self.logger.info(f"Binding heartbeat socket to {hb_endpoint}")
+        self.logger.debug(f"Binding heartbeat ROUTER socket to {hb_endpoint}")
 
     async def initialize_backend(self):
         """Initialize the storage backend."""
@@ -137,8 +137,8 @@ class AsyncRegistryServer:
 
         self._running = True
         self.logger.info(
-            f"Async registry server started on ports {self.req_port} (ROUTER-DEALER), {self.pub_port} (PUB), "
-            f"and {self.hb_port} (Heartbeat)"
+            f"Async registry server started on ports {self.req_port} (Requests ROUTER-DEALER), "
+            f"{self.pub_port} (Publish PUB), and {self.hb_port} (Heartbeat ROUTER)"
         )
 
         # Start the cleanup task
@@ -400,22 +400,35 @@ class AsyncRegistryServer:
         self.logger.info("Started heartbeats handler task")
 
         try:
+            message_parts = None
             while self._running:
                 try:
                     # Receive heartbeat (non-blocking with timeout)
-                    message_json = await asyncio.wait_for(self.hb_socket.recv_string(), timeout=1.0)
+                    message_parts = await asyncio.wait_for(self.hb_socket.recv_multipart(), timeout=1.0)
+
+                    self.logger.debug(f"{message_parts=}")
+
+                    if len(message_parts) == 2:
+                        client_id = message_parts[0]
+                        request = message_parts[1]
+
+                        # Parse the request
+                        request = json.loads(request)
+                        self.logger.info(f"Received heartbeat request: {request}")
 
-                    # Parse the request
-                    request = json.loads(message_json)
-                    self.logger.info(f"Received heartbeat request: {request}")
+                        response = await self._handle_renew(request)
+                        if VERBOSE_DEBUG:
+                            self.logger.debug(f"{response=}")
 
-                    response = await self._handle_renew(request)
+                        # Send the response
+                        await self.hb_socket.send_multipart([client_id, json.dumps(response).encode()])
 
-                    # Send the response
-                    await self.hb_socket.send_string(json.dumps(response))
+                    else:
+                        self.logger.warning("Heartbeat request: message corrupted, check debug messages.")
 
                 except asyncio.TimeoutError:
-                    # self.logger.debug("waiting for heartbeat...")
+                    if VERBOSE_DEBUG:
+                        self.logger.debug("waiting for heartbeat...")
                     continue
 
                 except Exception as exc:
@@ -526,12 +539,6 @@ async def start(
 ):
     """Run the registry server with signal handling."""
 
-    logging.basicConfig(
-        level=get_logging_level(log_level),
-        format="[%(asctime)s] %(threadName)-12s %(levelname)-8s %(name)-12s %(lineno)5d:%(module)-20s %(message)s",
-    )
-    logging.getLogger("aiosqlite").setLevel(logging.INFO)
-
     with remote_logging():
         server = AsyncRegistryServer(
             req_port=req_port,

{cgse-0.16.8 → cgse-0.16.10}/libs/cgse-core/src/egse/storage/storage_cs.py

@@ -62,6 +62,8 @@ class StorageControlServer(ControlServer):
 
         multiprocessing.current_process().name = PROCESS_NAME
 
+        self.scheduler: BackgroundScheduler | None = None
+
         self.logger = logger
         self.service_name = PROCESS_NAME
         self.service_type = SERVICE_TYPE
@@ -76,13 +78,6 @@ class StorageControlServer(ControlServer):
 
         self.register_service(service_type=SERVICE_TYPE)
 
-        # NOTE:
-        #     Since the CM CS is started after the SM CS in the normal startup sequence, delay the task to load
-        #     the Setup until after the CM CS has been properly started. We do that now with a delay time of 30s,
-        #     but we might in the future use a function returning a boolean, until...
-        # from egse.confman import is_configuration_manager_active
-        # self.schedule_task(self.device_protocol.controller.load_setup, after=10.0, when=is_configuration_manager_active)
-
     def before_serve(self):
         self.scheduler = BackgroundScheduler(timezone=utc)
         self.scheduler.start()

{cgse-0.16.8 → cgse-0.16.10}/libs/cgse-core/tests/script_test_registry_client_server.py

@@ -30,7 +30,6 @@ Notes:
 """
 
 import asyncio
-import logging
 import sys
 import time
 
@@ -88,7 +87,7 @@ def test_proper_termination_of_tasks_sync(
     assert response["name"] == "sync-context-test-service"
     assert response["metadata"]["msg"] == "Hello, World!"
 
-    print("Sleeping for 10s to let some heartbeats come through...")
+    print("Sleeping for 50s to let some heartbeats come through...")
     time.sleep(50.0)
 
     client.stop_heartbeat()
@@ -134,8 +133,8 @@ async def test_proper_termination_of_tasks_async(
     assert response["name"] == "async-context-test-service"
     assert response["metadata"]["msg"] == "Hello, World!"
 
-    print("Sleeping for 10s to let some heartbeats come through...")
-    await asyncio.sleep(10.0)
+    print("Sleeping for 50s to let some heartbeats come through...")
+    await asyncio.sleep(50.0)
 
     await client.stop_heartbeat()
     await client.deregister(service_id)
@@ -166,9 +165,4 @@ def main(
 
 
 if __name__ == "__main__":
-    logging.basicConfig(
-        level=logging.DEBUG,
-        format="[%(asctime)s] %(threadName)-12s %(levelname)-8s %(name)-12s %(lineno)5d:%(module)-20s %(message)s",
-    )
-
     sys.exit(app())

{cgse-0.16.8 → cgse-0.16.10}/libs/cgse-core/tests/test_registry_service.py

@@ -787,70 +787,3 @@ async def test_client_health_check(client, server):
     """Test health check."""
     health = await client.health_check()
     assert health is True
-
-
-@pytest.mark.asyncio
-async def test_client_caching(client, server):
-    """Test client's service caching."""
-
-    service_id = await client.register("cache-test-service", "localhost", 8080, service_type="cache-test")
-
-    # Look up the service (should populate cache)
-    service = await client.get_service(service_id)
-    assert service is not None
-
-    # Check if it's in the cache
-    async with client._service_cache_lock:
-        assert service_id in client._service_cache
-
-    # Look up by type (should use cache when use_cache=True)
-    with patch.object(client, "_send_request", new_callable=AsyncMock) as mock_send:
-        # First call with use_cache=True should check cache
-        service = await client.discover_service("cache-test", use_cache=True)
-        assert service is not None
-        assert service["id"] == service_id
-
-        # Configure the mock to return a dictionary that matches what _send_request would return
-        mock_send.return_value = {
-            "success": True,
-            "service": {
-                "id": service_id,
-                "name": "cache-test-service",
-                "host": "localhost",
-                "port": 8080,
-                "type": "cache-test",
-            },
-        }
-
-        # Second call with use_cache=False should make a request
-        service = await client.discover_service("cache-test", use_cache=False)
-        assert service is not None
-        assert mock_send.called
-
-
-@pytest.mark.asyncio
-async def test_client_register_context(client, server, req_socket):
-    """Test the register_context context manager."""
-
-    # Use the context manager
-    async with client.register_context(
-        "context-test-service", "localhost", 8080, service_type="context-test"
-    ) as service_id:
-        # Verify the service was registered
-        response = await send_request(
-            MessageType.REQUEST_WITH_REPLY, req_socket, {"action": "get", "service_id": service_id}
-        )
-
-        logger.info(f"----- In test_client_register_context: {response}")
-
-        assert response["success"] is True
-        assert response["service"]["name"] == "context-test-service"
-
-    logger.info("----- In test_client_register_context: after context...")
-
-    # After exiting the context, the service should be deregistered
-    response = await send_request(
-        MessageType.REQUEST_WITH_REPLY, req_socket, {"action": "get", "service_id": service_id}
-    )
-
-    assert response["success"] is False

{cgse-0.16.8 → cgse-0.16.10}/libs/cgse-gui/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-gui"
-version = "0.16.8"
+version = "0.16.10"
 description = "GUI components for CGSE"
 authors = [
     {name = "Rik Huygen", email = "rik.huygen@kuleuven.be"},

{cgse-0.16.8 → cgse-0.16.10}/projects/generic/cgse-tools/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-tools"
-version = "0.16.8"
+version = "0.16.10"
 description = "Tools for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.16.8 → cgse-0.16.10}/projects/generic/keithley-tempcontrol/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "keithley-tempcontrol"
-version = "0.16.8"
+version = "0.16.10"
 description = "Keithley Temperature Control for CGSE"
 authors = [
     {name = "IvS KU Leuven"}