python-swidget 1.4.13__tar.gz → 1.4.15__tar.gz

{python_swidget-1.4.13 → python_swidget-1.4.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-swidget
-Version: 1.4.13
+Version: 1.4.15
 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.13 → python_swidget-1.4.15}/pyproject.toml

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

{python_swidget-1.4.13 → python_swidget-1.4.15}/swidget/discovery.py

@@ -18,6 +18,36 @@ from .swidgettimerswitch import SwidgetTimerSwitch
 
 RESPONSE_SEC = 5
 SWIDGET_STS = ("urn:swidget:pico:1", "urn:swidget:video:1")
+
+# Per-ST raw device-id length (in hex chars) before any UUID padding. The
+# firmware embeds the device id in the SSDP USN differently per family:
+# pico uses a fixed UUID prefix + the 12-char id as the last segment;
+# video pads the 24-char id with zeros to fit a 32-char UUID. Both can
+# be recovered as long as we know the original length per ST.
+_USN_DEVICE_ID_LENGTH = {
+    "urn:swidget:pico:1": 12,
+    "urn:swidget:video:1": 24,
+}
+
+
+def device_id_from_ssdp(usn: str, st: str) -> Optional[str]:
+    """Extract the canonical device id from an SSDP USN/ST pair.
+
+    Returns None when the inputs aren't recognized — callers should treat
+    that as "skip this discovery" rather than synthesizing an id.
+    """
+    if not usn or not usn.startswith("uuid:") or st not in _USN_DEVICE_ID_LENGTH:
+        return None
+    uuid_part = usn[len("uuid:") :]
+    expected_len = _USN_DEVICE_ID_LENGTH[st]
+    if st == "urn:swidget:pico:1":
+        # Last hyphenated segment carries the real 12-char MAC.
+        last = uuid_part.rsplit("-", 1)[-1]
+        return last if len(last) == expected_len else None
+    # Video (and any future variant that pads): dehyphenate, take the
+    # leading expected_len chars, ignore the trailing zero padding.
+    flat = uuid_part.replace("-", "")
+    return flat[:expected_len] if len(flat) >= expected_len else None
 # Generous timeout: TLS handshakes on the device's MCU can take several
 # seconds on first connection.
 DETECT_TIMEOUT_SEC = 10
@@ -89,22 +119,27 @@ class SwidgetProtocol(ssdp.SimpleServiceDiscoveryProtocol):
     def response_received(self, response: ssdp.SSDPResponse, addr: tuple):
         """Handle an incoming response."""
         headers = {h[0]: h[1] for h in response.headers}
-        mac_address = headers["USN"].split("-")[-1]
+        st = headers.get("ST", "")
+        if st not in SWIDGET_STS:
+            return
+        device_id = device_id_from_ssdp(headers.get("USN", ""), st)
+        if not device_id:
+            _LOGGER.debug("Skipping SSDP response with unparseable USN: %s", headers)
+            return
         ip_address = urlparse(headers["LOCATION"]).hostname
-        if headers["ST"] in SWIDGET_STS:
-            device_type = headers["SERVER"].split(" ")[1].split("+")[0]
-            insert_type = headers["SERVER"].split(" ")[1].split("+")[1].split("/")[0]
-            friendly_name = headers["SERVER"].split("/")[2].strip('"')
-            devices[mac_address] = SwidgetDiscoveredDevice(
-                mac=mac_address,
-                host=ip_address,
-                friendly_name=friendly_name,
-                host_type=device_type,
-                insert_type=insert_type,
-            )
-            _LOGGER.debug(
-                f"Discovered Swidget device via SSDP: '{friendly_name}' at {ip_address} Type:{device_type}/{insert_type}"
-            )
+        device_type = headers["SERVER"].split(" ")[1].split("+")[0]
+        insert_type = headers["SERVER"].split(" ")[1].split("+")[1].split("/")[0]
+        friendly_name = headers["SERVER"].split("/")[2].strip('"')
+        devices[device_id] = SwidgetDiscoveredDevice(
+            mac=device_id,
+            host=ip_address,
+            friendly_name=friendly_name,
+            host_type=device_type,
+            insert_type=insert_type,
+        )
+        _LOGGER.debug(
+            f"Discovered Swidget device via SSDP: '{friendly_name}' at {ip_address} Type:{device_type}/{insert_type}"
+        )
 
 
 async def discover_devices(timeout=RESPONSE_SEC):

{python_swidget-1.4.13 → python_swidget-1.4.15}/swidget/swidgetdevice.py

@@ -249,6 +249,9 @@ class SwidgetDevice:
         ):
             _LOGGER.debug("Calling SwidgetDevice.process_state()")
             await self.process_state(message)
+        elif message["request_id"] == "device_config":
+            _LOGGER.debug("Calling SwidgetDevice.process_device_config()")
+            await self.process_device_config(message)
         else:
             message_type = ["request_id"]
             _LOGGER.error(
@@ -374,11 +377,33 @@ class SwidgetDevice:
             raise SwidgetConnectionException from e
 
     async def get_device_config(self) -> Any:
-        """Get the config of the device."""
+        """Refresh the local device_config cache.
+
+        Uses the websocket when available — the response lands on
+        ``message_callback`` with ``request_id == "device_config"`` and
+        ``process_device_config`` updates the cache. Falls back to HTTP
+        before the socket is connected (e.g. during entry pre-load).
+        """
         _LOGGER.debug("SwidgetDevice.get_device_config() called")
-        _LOGGER.debug("Sending get_summary() command over http")
+        if self.use_websockets and self.connected:
+            _LOGGER.debug("In websocket mode. Sending get_device_config over websocket")
+            await self._websocket.send_str(
+                json.dumps(
+                    {"type": "get_device_config", "request_id": "device_config"}
+                )
+            )
+            return
+        _LOGGER.debug("In http mode. Sending get_device_config over http")
         config = await self.make_http_request("GET", "device_config")
-        self.device_config = DeviceConfiguration(config)
+        await self.process_device_config(config)
+
+    async def process_device_config(self, config) -> None:
+        """Process a device_config payload from HTTP body or websocket message."""
+        _LOGGER.debug("SwidgetDevice.process_device_config() called")
+        # Strip transport metadata so DeviceConfiguration sees the same
+        # shape regardless of whether the payload arrived via HTTP or WS.
+        cfg = {k: v for k, v in config.items() if k != "request_id"}
+        self.device_config = DeviceConfiguration(cfg)
         self._last_update = int(time.time())
 
     async def set_device_config(self, updates: Dict[str, Any]) -> None:
@@ -499,7 +524,12 @@ class SwidgetDevice:
         self._last_update = int(time.time())
 
     async def update(self) -> None:
-        """Update the state, summary, config and name of the device."""
+        """Refresh state and summary; device_config is fetched separately.
+
+        device_config rarely changes, and a successful set_device_config
+        already pushes a fresh copy into the local cache, so we don't
+        re-fetch it on every coordinator poll.
+        """
         _LOGGER.debug("SwidgetDevice.update() called")
         if self._last_update == 0:
             _LOGGER.debug("Performing the initial update to obtain sysinfo")
@@ -507,8 +537,6 @@ class SwidgetDevice:
             await self.get_state()
             if self._friendly_name == "Unknown Swidget Device":
                 await self.get_friendly_name()
-            if not self.device_config.config_populated():
-                await self.get_device_config()
         elif (int(time.time()) - self._last_update) < 5:
             _LOGGER.debug("update() recently called, not executing")
         else: