python-swidget 1.4.6__tar.gz → 1.4.9__tar.gz

{python_swidget-1.4.6 → python_swidget-1.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-swidget
-Version: 1.4.6
+Version: 1.4.9
 Summary: Python API for Swidget smart devices
 Home-page: https://github.com/swidget/python-swidget
 License: GPL-3.0-or-later

{python_swidget-1.4.6 → python_swidget-1.4.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-swidget"
-version = "1.4.6"
+version = "1.4.9"
 description = "Python API for Swidget smart devices"
 license = "GPL-3.0-or-later"
 authors = ["Swidget"]

{python_swidget-1.4.6 → python_swidget-1.4.9}/swidget/swidgetdevice.py

@@ -361,10 +361,30 @@ class SwidgetDevice:
         self.model = summary["model"]
         self.mac_address = summary["mac"]
         self.version = summary["version"]
-        self.assemblies = {
+        new_assemblies = {
             "host": SwidgetAssembly(summary["host"]),
             "insert": SwidgetAssembly(summary["insert"]),
         }
+        # Carry already-populated function state forward. Rebuilding
+        # assemblies wholesale resets every component's ``functions`` to
+        # ``None`` placeholders until the next ``state`` message lands —
+        # subscribers that read state in between (e.g. an HA coordinator
+        # firing on the summary callback) would briefly see "unknown"
+        # and flicker the UI.
+        for assembly_key, new_assembly in new_assemblies.items():
+            old_assembly = self.assemblies.get(assembly_key)
+            if old_assembly is None:
+                continue
+            for component_id, new_component in new_assembly.components.items():
+                old_component = old_assembly.components.get(component_id)
+                if old_component is None:
+                    continue
+                for fn_name in new_component.functions:
+                    if fn_name in old_component.functions:
+                        new_component.functions[fn_name] = old_component.functions[
+                            fn_name
+                        ]
+        self.assemblies = new_assemblies
         self.device_type = DeviceType(self.assemblies["host"].type)
         self.insert_type = InsertType(self.assemblies["insert"].type)
         self.id = self.assemblies["host"].id
@@ -413,8 +433,15 @@ class SwidgetDevice:
             for id, component in self.assemblies[assembly].components.items():
                 try:
                     component.functions.update(state[assembly]["components"][id])
-                except Exception:
-                    pass
+                except Exception as exc:
+                    # Don't fail the whole state-process loop on one bad
+                    # component, but DO surface what was skipped — silent
+                    # failures here are how is_on ends up reading from a
+                    # never-populated None placeholder.
+                    _LOGGER.debug(
+                        f"process_state: skipped {assembly}/{id} "
+                        f"({type(exc).__name__}: {exc})"
+                    )
         self._last_update = int(time.time())
 
     async def update(self) -> None:

{python_swidget-1.4.6 → python_swidget-1.4.9}/swidget/websocket.py

@@ -27,7 +27,7 @@ class SwidgetWebsocket:
         session: aiohttp.ClientSession | None = None,
         use_security: bool = True,
         verify_ssl: bool = False,
-        retry_interval: int = 30,  # Initial retry interval in seconds
+        retry_interval: int = 5,  # Initial retry interval in seconds
         max_retries: int | None = None,  # Maximum number of reconnection attempts
     ):
         """Initialize the SwidgetWebsocket.
@@ -106,27 +106,31 @@ class SwidgetWebsocket:
             self._client = None
 
     async def send_str(self, message: str) -> None:
-        """Send a string message through the websocket with retry attempts."""
+        """Send a string message through the websocket.
+
+        Drops the message (no retry) if the connection is missing or in
+        a closing state. Retrying against a closing transport just wastes
+        time — the right recovery is to invalidate the client so the
+        run() loop's reconnect kicks in on the next iteration.
+        """
         _LOGGER.debug(f"[{self.host}] websocket.send_str: {message}")
-        max_send_retries = 3
-        for attempt in range(max_send_retries):
-            try:
-                if self._client is not None:
-                    await self._client.send_str(message)
-                    return
-                else:
-                    _LOGGER.warning("Websocket is not connected, not sending")
-                    return
-            except Exception as e:
-                _LOGGER.warning(
-                    f"Error sending message, attempt {attempt}/{max_send_retries}: {e}"
-                )
-                if attempt < max_send_retries - 1:
-                    await asyncio.sleep(5**attempt)
-                else:
-                    _LOGGER.error(
-                        f"Failed to send message after {max_send_retries} attempts."
-                    )
+        if self._client is None or self._client.closed:
+            if self._client is not None:
+                # aiohttp says it's closed but we still hold a reference;
+                # clear it so run() reconnects on the next loop.
+                self._client = None
+            _LOGGER.warning(
+                f"[{self.host}] websocket not connected, dropping message"
+            )
+            return
+        try:
+            await self._client.send_str(message)
+        except Exception as e:
+            _LOGGER.warning(
+                f"[{self.host}] websocket send failed ({e}); invalidating client"
+            )
+            # Force the run() loop's reconnect path on the next iteration.
+            self._client = None
 
     async def receive(self) -> Any | None:
         """Receive a message from the WebSocket server."""
@@ -180,8 +184,9 @@ class SwidgetWebsocket:
             )
 
         self.retry_count += 1
-        # Implement exponential backoff for reconnection delay
-        delay = self.retry_interval * (2 ** (self.retry_count - 1))
+        # Exponential backoff capped at 60s so a long outage doesn't push
+        # the next attempt out by hours.
+        delay = min(self.retry_interval * (2 ** (self.retry_count - 1)), 60)
         _LOGGER.warning(
             f"Reconnecting to Swidget device: {self.host} in {delay} seconds (attempt {self.retry_count})..."
         )