python-swidget 1.4.17__tar.gz → 1.4.20__tar.gz

{python_swidget-1.4.17 → python_swidget-1.4.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-swidget
-Version: 1.4.17
+Version: 1.4.20
 Summary: Python API for Swidget smart devices
 Home-page: https://github.com/swidget/python-swidget
 License: GPL-3.0-or-later
@@ -23,7 +23,7 @@ Requires-Dist: mistune (<2.0.0) ; extra == "docs"
 Requires-Dist: pydantic (>=2,<3)
 Requires-Dist: requests (>=2.32,<3.0)
 Requires-Dist: sphinx (>=4,<5) ; extra == "docs"
-Requires-Dist: sphinx_rtd_theme (>=0,<1) ; extra == "docs"
+Requires-Dist: sphinx_rtd_theme (>=1.2,<2.0) ; extra == "docs"
 Requires-Dist: sphinxcontrib-programoutput (>=0,<1) ; extra == "docs"
 Requires-Dist: ssdp (==1.1.1)
 Requires-Dist: types-requests (>=2.32.0,<3.0.0)

{python_swidget-1.4.17 → python_swidget-1.4.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-swidget"
-version = "1.4.17"
+version = "1.4.20"
 description = "Python API for Swidget smart devices"
 license = "GPL-3.0-or-later"
 authors = ["Swidget"]
@@ -30,7 +30,7 @@ urllib3 = "^2.0"
 sphinx = { version = "^4", optional = true }
 m2r = { version = "^0", optional = true }
 mistune = { version = "<2.0.0", optional = true }
-sphinx_rtd_theme = { version = "^0", optional = true }
+sphinx_rtd_theme = { version = "^1.2", optional = true }
 sphinxcontrib-programoutput = { version = "^0", optional = true }
 
 [tool.poetry.dev-dependencies]
@@ -50,6 +50,9 @@ coverage = {version = "^6", extras = ["toml"]}
 sphinx = "^4"
 sphinx-autobuild = "^2021.3.14"
 sphinx-rtd-theme = "^1.2"
+# docutils 0.21.post1 is listed on PyPI with no downloadable files, which
+# breaks poetry's resolver; sphinx 4 needs <0.18 anyway.
+docutils = "<0.21"
 mypy = "^1.11"
 black = "^24.4"
 

{python_swidget-1.4.17 → python_swidget-1.4.20}/swidget/cli.py

@@ -27,6 +27,7 @@ TYPE_TO_CLASS = {
     "pana_switch": SwidgetTimerSwitch,
     "pesna_fv05": SwidgetFan,
     "pesna_fv15": SwidgetFan,
+    "pesna_fv15_plus": SwidgetFan,
     "pesna_fv20": SwidgetFan,
     "pesna_IB150": SwidgetFan,
     "pesna_IB160": SwidgetFan,

{python_swidget-1.4.17 → python_swidget-1.4.20}/swidget/discovery.py

@@ -2,7 +2,7 @@
 import asyncio
 import logging
 import socket
-from typing import Any, Type
+from typing import Any, Optional, Type
 from urllib.parse import urlparse
 
 import ssdp
@@ -59,10 +59,19 @@ devices = dict()
 async def detect_secure(host: str, timeout: float = DETECT_TIMEOUT_SEC) -> bool:
     """Determine whether a Swidget device requires HTTPS+auth.
 
-    Probes ``/api/v1/summary`` over HTTPS first (no credentials). A 403
-    response means the firmware enforces auth — the device is in secure
-    mode. If HTTPS is unreachable, falls back to HTTP; a 200 there means
-    the device is in plaintext mode.
+    Probes ``/api/v1/summary`` over HTTP first; a 200 means the device
+    is in plaintext mode. Secure-mode firmware running on the same port
+    answers 403 ("TLS required") instead, so anything non-200 falls
+    through to the HTTPS probe.
+
+    On HTTPS, both 401 and 403 indicate secure mode:
+    - **401 "Authorization Missing"** — no token in the request (our
+      probe doesn't carry one).
+    - **403 "Forbidden"** — token rejected ("Incorrect Token") or the
+      device's secret key has never been provisioned ("Key not set").
+
+    Both states mean "secure mode is enforced, prompt the caller for
+    credentials", so we collapse them into a single True return.
 
     :param host: Hostname or IP of the device.
     :param timeout: Per-request timeout in seconds. Defaults are generous
@@ -83,10 +92,12 @@ async def detect_secure(host: str, timeout: float = DETECT_TIMEOUT_SEC) -> bool:
         except (ClientError, asyncio.TimeoutError):
             pass
 
-        # Fall back to HTTPS. A 403 means the firmware is enforcing auth.
+        # Fall back to HTTPS. 401 ("Authorization Missing") and 403
+        # ("Forbidden" — wrong token, or key not set) both mean the
+        # firmware is in secure mode; the caller now needs credentials.
         try:
             async with session.get(f"https://{host}/api/v1/summary") as resp:
-                if resp.status == 403:
+                if resp.status in (401, 403):
                     return True
         except (ClientError, asyncio.TimeoutError):
             pass
@@ -199,6 +210,7 @@ _PESNA_DEVICE_TYPES = frozenset(
     {
         DeviceType.PesnaFV05,
         DeviceType.PesnaFV15,
+        DeviceType.PesnaFV15Plus,
         DeviceType.PesnaFV20,
         DeviceType.PesnaIB150,
         DeviceType.PesnaIB160,

{python_swidget-1.4.17 → python_swidget-1.4.20}/swidget/swidgetdevice.py

@@ -6,7 +6,7 @@ import time
 from collections.abc import Callable
 from enum import Enum
 from types import TracebackType
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 from aiohttp import ClientSession, TCPConnector
 from aiohttp.client_exceptions import ClientConnectorError
@@ -39,6 +39,7 @@ class DeviceType(Enum):
     RelaySwitch = "relay_switch"
     PesnaFV05 = "pesna_fv05"
     PesnaFV15 = "pesna_fv15"
+    PesnaFV15Plus = "pesna_fv15_plus"
     PesnaFV20 = "pesna_fv20"
     PesnaIB150 = "pesna_IB150"
     PesnaIB160 = "pesna_IB160"
@@ -124,6 +125,24 @@ class SelfDiagnosticErrorCodes(Enum):
     PART_MATTER = 14
 
 
+def _deep_merge_dicts(base: Dict[str, Any], updates: Dict[str, Any]) -> Dict[str, Any]:
+    """Return a new dict with ``updates`` deep-merged onto ``base``.
+
+    Used by ``process_device_config`` so that partial-update websocket
+    pushes don't wipe untouched top-level keys out of the cache. Lists
+    and scalars are replaced (not concatenated) — this is a config tree,
+    not an event log.
+    """
+    result: Dict[str, Any] = dict(base)
+    for key, value in updates.items():
+        existing = result.get(key)
+        if isinstance(value, dict) and isinstance(existing, dict):
+            result[key] = _deep_merge_dicts(existing, value)
+        else:
+            result[key] = value
+    return result
+
+
 class SwidgetDevice:
     """Core representation of a Swidget device (base class for all device types)."""
 
@@ -398,12 +417,31 @@ class SwidgetDevice:
         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."""
+        """Process a device_config payload from HTTP body or websocket message.
+
+        Both transports use the same callback path, but the firmware
+        pushes a *partial* websocket message after every config write
+        (only the changed leaves) using the same request_id as the full
+        GET response. Replacing the cache wholesale would let those
+        partial pushes silently wipe every other top-level key, which
+        in turn breaks every other config-driven entity in the consumer.
+
+        Deep-merging the incoming dict into the existing cache gives the
+        right behaviour for both shapes: a full GET overwrites every
+        leaf (functionally a replace), and a partial push updates only
+        what it touches.
+        """
         _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)
+        existing = (
+            self.device_config.config
+            if self.device_config is not None and self.device_config.config_populated()
+            else {}
+        )
+        merged = _deep_merge_dicts(existing, cfg)
+        self.device_config = DeviceConfiguration(merged)
         self._last_update = int(time.time())
 
     async def set_device_config(self, updates: Dict[str, Any]) -> None:
@@ -413,10 +451,22 @@ class SwidgetDevice:
         (only the changed leaves), so callers should pass the same nested
         shape ``get_device_config()`` returns. After the POST succeeds the
         local cache is refreshed so reads see the new value immediately.
+
+        We refresh via HTTP rather than ``get_device_config()`` because
+        the websocket variant is fire-and-forget — it sends a request and
+        returns before the response is delivered to ``message_callback``.
+        Worse, the firmware also pushes a websocket message of the
+        *changed leaves only* on every config write, and
+        ``process_device_config`` replaces the cache wholesale rather
+        than merging — so a partial push arriving after a full GET would
+        silently wipe everything else out of the cache. The synchronous
+        HTTP read here guarantees the cache is the full config when we
+        return.
         """
         _LOGGER.debug("SwidgetDevice.set_device_config(%s) called", updates)
         await self.make_http_request("POST", "device_config", json_payload=updates)
-        await self.get_device_config()
+        config = await self.make_http_request("GET", "device_config")
+        await self.process_device_config(config)
 
     async def get_summary(self) -> None:
         """Get a summary of the device over HTTP."""
@@ -561,9 +611,14 @@ class SwidgetDevice:
             )
 
     async def send_command(
-        self, assembly: str, component: str, function: str, command: dict
+        self, assembly: str, component: str, function: str, command: Union[dict, str]
     ) -> None:
-        """Send a command to the Swidget device either using a HTTP call or the existing websocket."""
+        """Send a command to the Swidget device either using a HTTP call or the existing websocket.
+
+        ``command`` is placed verbatim under the function key. Most
+        functions take an object, but a few (the Pesna fan ``mode`` and
+        ``speed``) expect a bare string value.
+        """
         _LOGGER.debug("SwidgetDevice.send_command() called")
         data = {assembly: {"components": {component: {function: command}}}}
         _LOGGER.debug(f"Command to send: {data}")