ucapi-framework 1.9.5__tar.gz → 1.9.7__tar.gz

{ucapi_framework-1.9.5 → ucapi_framework-1.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ucapi-framework
-Version: 1.9.5
+Version: 1.9.7
 Summary: ucapi framework that provides core functionality for building integrations.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{ucapi_framework-1.9.5 → ucapi_framework-1.9.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ucapi-framework"
-version = "1.9.5"
+version = "1.9.7"
 description = "ucapi framework that provides core functionality for building integrations."
 readme = "README.md"
 requires-python = ">=3.11"

{ucapi_framework-1.9.5 → ucapi_framework-1.9.7}/tests/test_device.py

@@ -771,6 +771,63 @@ class TestWebSocketDevice:
 
         await device.disconnect()
 
+    @pytest.mark.asyncio
+    async def test_normal_close_cleans_up_before_reconnect(
+        self, mock_device_config, event_loop
+    ):
+        """A clean close must not leak the old socket or reconnect in a tight loop."""
+
+        class ClosingWebSocketDevice(ConcreteWebSocketDevice):
+            def __init__(self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+                self.attempt_times = []
+                self.closed_count = 0
+                self.second_attempt = asyncio.Event()
+
+            async def create_websocket(self):
+                self.attempt_times.append(event_loop.time())
+                if len(self.attempt_times) == 2:
+                    self.second_attempt.set()
+                return Mock()
+
+            async def receive_message(self):
+                return None
+
+            async def close_websocket(self):
+                self.closed_count += 1
+
+        device = ClosingWebSocketDevice(
+            mock_device_config,
+            loop=event_loop,
+            reconnect_interval=0.05,
+            ping_interval=30,
+        )
+
+        await device.connect()
+        await asyncio.wait_for(device.second_attempt.wait(), timeout=1)
+
+        assert device.closed_count >= 1
+        assert device.attempt_times[1] - device.attempt_times[0] >= 0.04
+        await device.disconnect()
+        assert device._ping_task is None
+        assert device._ws is None
+
+    @pytest.mark.asyncio
+    async def test_single_connection_stops_ping_on_normal_close(
+        self, mock_device_config, event_loop
+    ):
+        """A one-shot connection releases its ping task when the peer closes."""
+        device = ConcreteWebSocketDevice(
+            mock_device_config, loop=event_loop, reconnect=False
+        )
+
+        await device.connect()
+        await asyncio.wait_for(device._ws_task, timeout=1)
+
+        assert device.ws_closed is True
+        assert device._ping_task is None
+        assert device._ws is None
+
     @pytest.mark.asyncio
     async def test_websocket_connection_error_no_reconnect(
         self, mock_device_config, event_loop

{ucapi_framework-1.9.5 → ucapi_framework-1.9.7}/tests/test_driver.py

@@ -1442,6 +1442,34 @@ class TestHubBasedIntegration:
         # Device should be connected
         assert device.is_connected is True
 
+    @pytest.mark.asyncio
+    async def test_on_subscribe_entities_hub_based_existing_connected_unconfigured_entity(
+        self,
+    ):
+        """Test subscribing registers hub entities when the device already connected."""
+        loop = asyncio.get_event_loop()
+        driver = ConcreteDriver(
+            DeviceForTests,
+            [media_player.MediaPlayer],
+            require_connection_before_registry=True,
+            loop=loop,
+        )
+        driver.api = MagicMock()
+        driver.api.configured_entities = MockEntityCollection()
+        driver.api.available_entities = MockEntityCollection()
+        driver.api.set_device_state = AsyncMock()
+
+        config = DeviceConfigForTests("dev1", "Device 1", "192.168.1.1")
+        driver._add_device_instance(config)
+        device = driver._device_instances["dev1"]
+        await device.connect()
+        assert device.is_connected is True
+        assert driver.api.configured_entities.get("media_player.dev1") is None
+
+        await driver.on_subscribe_entities(["media_player.dev1"])
+
+        assert driver.api.available_entities.contains("media_player.dev1")
+
     @pytest.mark.asyncio
     async def test_on_subscribe_entities_hub_based_no_config(self):
         """Test subscribe entities with hub-based when device config not found."""

{ucapi_framework-1.9.5 → ucapi_framework-1.9.7}/ucapi_framework/device.py

@@ -572,15 +572,6 @@ class WebSocketDevice(BaseDeviceInterface):
         _LOG.debug("[%s] Disconnecting WebSocket", self.log_id)
         self._stop_ws.set()
 
-        # Stop ping task
-        if self._ping_task and not self._ping_task.done():
-            self._ping_task.cancel()
-            try:
-                await self._ping_task
-            except asyncio.CancelledError:
-                pass
-        self._ping_task = None
-
         # Stop connection task
         if self._ws_task and not self._ws_task.done():
             self._ws_task.cancel()
@@ -589,17 +580,31 @@ class WebSocketDevice(BaseDeviceInterface):
             except asyncio.CancelledError:
                 pass
 
-        # Close WebSocket
+        await self._cleanup_websocket()
+        self._ws_task = None
+        self.events.emit(DeviceEvents.DISCONNECTED, self.identifier)
+
+    async def _cleanup_websocket(self) -> None:
+        """Release the ping task and socket after any connection outcome."""
+        self._is_connected = False
+
+        if self._ping_task:
+            ping_task = self._ping_task
+            self._ping_task = None
+            if not ping_task.done():
+                ping_task.cancel()
+            try:
+                await ping_task
+            except asyncio.CancelledError:
+                pass
+
         if self._ws:
             try:
                 await self.close_websocket()
             except Exception as err:  # pylint: disable=broad-exception-caught
                 _LOG.debug("[%s] Error closing WebSocket: %s", self.log_id, err)
-            self._ws = None
-
-        self._ws_task = None
-        self._is_connected = False
-        self.events.emit(DeviceEvents.DISCONNECTED, self.identifier)
+            finally:
+                self._ws = None
 
     async def _single_connect(self) -> None:
         """Single connection attempt without reconnection."""
@@ -624,13 +629,7 @@ class WebSocketDevice(BaseDeviceInterface):
             _LOG.error("[%s] WebSocket connection error: %s", self.log_id, err)
             self.events.emit(DeviceEvents.ERROR, self.identifier, str(err))
         finally:
-            self._is_connected = False
-            if self._ws:
-                try:
-                    await self.close_websocket()
-                except Exception:  # pylint: disable=broad-exception-caught
-                    pass
-                self._ws = None
+            await self._cleanup_websocket()
 
     async def _connection_loop(self) -> None:
         """
@@ -668,40 +667,25 @@ class WebSocketDevice(BaseDeviceInterface):
             except Exception as err:  # pylint: disable=broad-exception-caught
                 _LOG.warning("[%s] WebSocket connection error: %s", self.log_id, err)
                 self.events.emit(DeviceEvents.ERROR, self.identifier, str(err))
-                self._is_connected = False
+            finally:
+                await self._cleanup_websocket()
 
-                # Clean up
-                if self._ping_task and not self._ping_task.done():
-                    self._ping_task.cancel()
-                    try:
-                        await self._ping_task
-                    except asyncio.CancelledError:
-                        pass
-                    self._ping_task = None
-
-                if self._ws:
-                    try:
-                        await self.close_websocket()
-                    except Exception:  # pylint: disable=broad-exception-caught
-                        pass
-                    self._ws = None
-
-                # Exponential backoff for reconnection
-                if not self._stop_ws.is_set():
-                    _LOG.debug(
-                        "[%s] Reconnecting in %d seconds",
-                        self.log_id,
-                        self._backoff_current,
-                    )
-                    try:
-                        await asyncio.wait_for(
-                            self._stop_ws.wait(), timeout=self._backoff_current
-                        )
-                    except asyncio.TimeoutError:
-                        pass
-                    self._backoff_current = min(
-                        self._backoff_current * 2, self._reconnect_max
+            # A normal close also needs cleanup and a paced reconnect.
+            if not self._stop_ws.is_set():
+                _LOG.debug(
+                    "[%s] Reconnecting in %s seconds",
+                    self.log_id,
+                    self._backoff_current,
+                )
+                try:
+                    await asyncio.wait_for(
+                        self._stop_ws.wait(), timeout=self._backoff_current
                     )
+                except asyncio.TimeoutError:
+                    pass
+                self._backoff_current = min(
+                    self._backoff_current * 2, self._reconnect_max
+                )
 
     async def _message_loop(self) -> None:
         """Main message loop for receiving WebSocket messages."""

{ucapi_framework-1.9.5 → ucapi_framework-1.9.7}/ucapi_framework/driver.py

@@ -395,6 +395,25 @@ class BaseIntegrationDriver(Generic[DeviceT, ConfigT]):
                     await self.async_register_available_entities(
                         self.get_device_config(device_id), device
                     )
+                elif (
+                    device
+                    and device.is_connected
+                    and self.api.configured_entities.get(entity_id) is None
+                ):
+                    # PATCHED: the device was already connected (e.g. by the
+                    # generic CONNECT handler on Remote restart) before this
+                    # SUBSCRIBE_ENTITIES call arrived, so the transition-only
+                    # registration above never ran. Register now so the
+                    # entity doesn't silently stay unconfigured.
+                    _LOG.info(
+                        "Device %s already connected but entity %s not configured "
+                        "- registering now (post-restart fix)",
+                        device_id,
+                        entity_id,
+                    )
+                    await self.async_register_available_entities(
+                        self.get_device_config(device_id), device
+                    )
 
         # Path 2: Standard integrations - add devices for entities that aren't configured yet
         else:

{ucapi_framework-1.9.5 → ucapi_framework-1.9.7}/ucapi_framework.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ucapi-framework
-Version: 1.9.5
+Version: 1.9.7
 Summary: ucapi framework that provides core functionality for building integrations.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown