pywiim 2.2.1__tar.gz → 2.2.3__tar.gz

{pywiim-2.2.1/pywiim.egg-info → pywiim-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pywiim
-Version: 2.2.1
+Version: 2.2.3
 Summary: Python library for WiiM/LinkPlay device communication
 Author-email: Michael Cumming <mjcumming@gmail.com>
 License: MIT

{pywiim-2.2.1 → pywiim-2.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pywiim"
-version = "2.2.1"
+version = "2.2.3"
 description = "Python library for WiiM/LinkPlay device communication"
 readme = "README.md"
 requires-python = ">=3.11"

{pywiim-2.2.1 → pywiim-2.2.3}/pywiim/__init__.py

@@ -87,7 +87,7 @@ from .profiles import (
 from .role import RoleDetectionResult, detect_role
 from .state import GroupStateSynchronizer, StateSynchronizer
 
-__version__ = "2.2.1"
+__version__ = "2.2.3"
 __all__ = [
     # Main client
     "WiiMClient",

{pywiim-2.2.1 → pywiim-2.2.3}/pywiim/api/parser.py

@@ -469,7 +469,7 @@ def _handle_qobuz_connect_state_quirks(data: dict[str, Any], raw: dict[str, Any]
     """Handle Qobuz Connect state detection quirks.
 
     Addresses GitHub issue #35: Qobuz Connect shows playing briefly then switches to idle.
-    This implements the enhanced state detection logic that was added in python-linkplay v0.2.9.
+    Also handles HTTP ``status: "none"`` with live timeline/metadata (mjcumming/wiim#222).
 
     Args:
         data: Parsed data dictionary (modified in place)
@@ -477,16 +477,30 @@ def _handle_qobuz_connect_state_quirks(data: dict[str, Any], raw: dict[str, Any]
     """
     current_status = data.get("play_status", "").lower()
 
-    # Only apply workaround when status appears to be incorrectly reported as stopped/idle
-    if current_status not in {"stop", "stopped", "idle", ""}:
-        return  # Status appears correct, don't interfere
+    # Only skip when the device already reports a normal transport state we should not override.
+    # Qobuz Connect often reports ``status: "none"`` while ``curpos`` / ``totlen`` and metadata
+    # still reflect an active stream (see mjcumming/wiim#222); ``none`` must not bypass this path.
+    if current_status in {
+        "play",
+        "playing",
+        "pause",
+        "paused",
+        "paused playback",
+        "load",
+        "loading",
+        "buffering",
+        "transitioning",
+    }:
+        return
 
     # Enhanced detection: Look for multiple indicators that suggest active playback
     # This mimics the improved logic from python-linkplay v0.2.9
 
     title = data.get("title")
     has_track_info = bool(title and isinstance(title, str) and title.strip() and title != "Unknown")
-    has_position_info = bool(data.get("position") or raw.get("curpos") or raw.get("offset_pts"))
+    has_position_info = (
+        data.get("position") is not None or raw.get("curpos") is not None or raw.get("offset_pts") is not None
+    )
     has_duration_info = bool(data.get("duration") or raw.get("totlen"))
     has_artwork = bool(data.get("entity_picture") or raw.get("cover") or raw.get("albumArtURI"))
 

{pywiim-2.2.1 → pywiim-2.2.3}/pywiim/api/subwoofer.py

@@ -42,6 +42,27 @@ from .constants import (
     SUBWOOFER_PHASE_180,
 )
 
+_SUBWOOFER_LPF_KNOWN_KEYS = frozenset(
+    {"cross", "plugged", "sub_delay", "main_filter", "sub_filter", "mix_sub", "output_mode"}
+)
+
+
+def is_valid_subwoofer_lpf_dict(parsed: Any) -> bool:
+    """True when *parsed* is a real getSubLPF status object (not an API error wrapper).
+
+    Some vendors return HTTP 200 with JSON like ``{\"error\": \"unsupported_command\"}``;
+    those must not be treated as subwoofer support or coerced into :class:`SubwooferStatus`.
+    """
+    if not isinstance(parsed, dict):
+        return False
+    if "error" in parsed:
+        return False
+    keys = parsed.keys()
+    if keys & _SUBWOOFER_LPF_KNOWN_KEYS:
+        return True
+    st = parsed.get("status")
+    return isinstance(st, int) and ("level" in parsed or "phase" in parsed)
+
 
 @dataclass
 class SubwooferStatus:
@@ -161,7 +182,7 @@ class SubwooferAPI:
         """
         try:
             response = await self._request(API_ENDPOINT_SUBWOOFER_STATUS)  # type: ignore[attr-defined]
-            if isinstance(response.parsed, dict):
+            if isinstance(response.parsed, dict) and is_valid_subwoofer_lpf_dict(response.parsed):
                 return SubwooferStatus.from_dict(response.parsed)
             return None
         except WiiMError:
@@ -175,7 +196,9 @@ class SubwooferAPI:
         """
         try:
             response = await self._request(API_ENDPOINT_SUBWOOFER_STATUS)  # type: ignore[attr-defined]
-            return response.parsed if isinstance(response.parsed, dict) else None
+            if isinstance(response.parsed, dict) and is_valid_subwoofer_lpf_dict(response.parsed):
+                return response.parsed
+            return None
         except WiiMError:
             return None
 

{pywiim-2.2.1 → pywiim-2.2.3}/pywiim/capabilities.py

@@ -25,6 +25,7 @@ The capability detection system uses a multi-layer approach:
 
 from __future__ import annotations
 
+import asyncio
 import logging
 from typing import Any
 from urllib.parse import quote
@@ -37,9 +38,11 @@ from .api.constants import (
     API_ENDPOINT_GET_CHANNEL_BALANCE,
     API_ENDPOINT_PEQ_GET_LIST,
     API_ENDPOINT_SET_LED,
+    API_ENDPOINT_SUBWOOFER_STATUS,
     API_ENDPOINT_TRIGGER_OUT_STATUS,
     PEQ_PLUGIN_URI,
 )
+from .api.subwoofer import is_valid_subwoofer_lpf_dict
 from .exceptions import WiiMError
 from .model_names import is_known_wiim_model, is_wiim_ultra
 from .models import DeviceInfo
@@ -87,6 +90,69 @@ def _channel_balance_probe_success(response: ApiResponse) -> bool:
     return True
 
 
+def _subwoofer_probe_error_definitively_unsupported(err: Exception) -> bool:
+    """True when the error indicates the endpoint/command is not available."""
+    s = str(err).lower()
+    return "unknown command" in s or "404" in s or "not found" in s
+
+
+async def _probe_supports_subwoofer(client: Any, device_info: DeviceInfo, capabilities: dict[str, Any]) -> bool | None:
+    """Runtime probe for getSubLPF (same backing as get_subwoofer_status_raw).
+
+    Returns:
+        True if supported, False if definitively unsupported, None for WiiM when
+        the probe stays inconclusive after retries (transient errors).
+    """
+    if not capabilities.get("is_wiim_device"):
+        return False
+
+    host = getattr(client, "host", "?")
+    model = device_info.model or "unknown"
+    max_attempts = 3
+    last_err: Exception | None = None
+
+    for attempt in range(max_attempts):
+        try:
+            r = await client._request(API_ENDPOINT_SUBWOOFER_STATUS)
+            if is_valid_subwoofer_lpf_dict(r.parsed):
+                if attempt:
+                    _LOGGER.debug("getSubLPF succeeded on retry for host=%s model=%s", host, model)
+                return True
+            raw_preview = (r.raw or "")[:200] if r.raw else None
+            _LOGGER.debug(
+                "Subwoofer probe host=%s model=%s: unsupported or invalid response "
+                "(expected subwoofer dict); parsed_type=%s raw_preview=%r",
+                host,
+                model,
+                type(r.parsed).__name__,
+                raw_preview,
+            )
+            return False
+        except Exception as err:
+            last_err = err
+            if _subwoofer_probe_error_definitively_unsupported(err):
+                _LOGGER.debug(
+                    "Subwoofer probe host=%s model=%s: unsupported (error=%s)",
+                    host,
+                    model,
+                    err,
+                )
+                return False
+            if attempt < max_attempts - 1 and is_legacy_firmware_error(err):
+                await asyncio.sleep(0.15)
+                continue
+            break
+
+    _LOGGER.warning(
+        "Subwoofer probe inconclusive for host=%s model=%s after %d attempts: %s",
+        host,
+        model,
+        max_attempts,
+        last_err,
+    )
+    return None
+
+
 __all__ = [
     "WiiMCapabilities",
     "detect_device_capabilities",
@@ -115,12 +181,17 @@ class WiiMCapabilities:
         self._firmware_versions: dict[str, str] = {}
         self._device_types: dict[str, str] = {}
 
-    async def detect_capabilities(self, client: Any, device_info: DeviceInfo) -> dict[str, Any]:
+    def invalidate_device(self, device_id: str) -> None:
+        """Drop cached capabilities for one device (host:uuid) so the next detect re-probes."""
+        self._capabilities.pop(device_id, None)
+
+    async def detect_capabilities(self, client: Any, device_info: DeviceInfo, *, force: bool = False) -> dict[str, Any]:
         """Probe device capabilities and cache results.
 
         Args:
             client: WiiM API client instance (must have _request method and host attribute)
             device_info: Device information from getStatusEx
+            force: When True, ignore cached capabilities and re-run all probes.
 
         Returns:
             Dictionary of device capabilities with vendor, device type, firmware,
@@ -128,7 +199,7 @@ class WiiMCapabilities:
         """
         device_id = f"{client.host}:{device_info.uuid}"
 
-        if device_id in self._capabilities:
+        if not force and device_id in self._capabilities:
             # Return cached capabilities, but ensure vendor is normalized
             cached = self._capabilities[device_id].copy()
             if "vendor" not in cached or not cached.get("vendor"):
@@ -391,6 +462,9 @@ class WiiMCapabilities:
         except WiiMError:
             _LOGGER.debug("Device %s does not support 12V trigger (getTriggeroutStatus)", client.host)
 
+        # Subwoofer (getSubLPF) — WiiM-only read probe; same endpoint as get_subwoofer_status_raw()
+        capabilities["supports_subwoofer"] = await _probe_supports_subwoofer(client, device_info, capabilities)
+
         # Probe for Status Light (LED_SWITCH_SET) - "Status Light" in app; some devices use this instead of setLED
         try:
             await client._request(f"{API_ENDPOINT_SET_LED}0")

{pywiim-2.2.1 → pywiim-2.2.3}/pywiim/client.py

@@ -140,7 +140,7 @@ class WiiMClient(
         self._capabilities_detected = capabilities is not None
         self._detecting_capabilities = False  # Flag to prevent recursion
 
-    async def _detect_capabilities(self) -> dict[str, Any]:
+    async def _detect_capabilities(self, force: bool = False) -> dict[str, Any]:
         """Detect device capabilities and update client configuration.
 
         This method is called automatically on first use if capabilities were not
@@ -151,13 +151,17 @@ class WiiMClient(
         - Protocol preferences
         - Generation-specific quirks
 
+        Args:
+            force: When True, bypass the early return and re-run probing (used by
+                :meth:`refresh_capabilities` so OTA firmware can change support flags).
+
         Returns:
             Dictionary of detected capabilities.
 
         Raises:
             WiiMError: If capability detection fails.
         """
-        if self._capabilities_detected:
+        if self._capabilities_detected and not force:
             return self._capabilities
 
         try:
@@ -165,7 +169,7 @@ class WiiMClient(
             device_info = await BaseWiiMClient.get_device_info_model(self)
 
             # Detect capabilities using the capability detector
-            capabilities = await self._capability_detector.detect_capabilities(self, device_info)
+            capabilities = await self._capability_detector.detect_capabilities(self, device_info, force=force)
 
             # Ensure vendor is normalized (safety check)
             from .normalize import normalize_vendor
@@ -227,6 +231,7 @@ class WiiMClient(
                 upnp_caps = await self._safe_collect_upnp_description_capabilities()
                 if upnp_caps:
                     capabilities.update(upnp_caps)
+                capabilities.setdefault("supports_subwoofer", False)
                 self._capabilities.update(capabilities)
                 self._capabilities_detected = True
                 return self._capabilities
@@ -235,6 +240,22 @@ class WiiMClient(
                 self._capabilities_detected = True
                 return self._capabilities
 
+    async def refresh_capabilities(self, force: bool = True) -> dict[str, Any]:
+        """Re-run capability detection including runtime probes (e.g. after firmware OTA).
+
+        Args:
+            force: When True (default), drop the detector cache for this device so
+                probes such as getSubLPF run again.
+
+        Returns:
+            Updated capabilities dict (same object as :attr:`capabilities`).
+        """
+        device_info = await BaseWiiMClient.get_device_info_model(self)
+        if force:
+            self._capability_detector.invalidate_device(f"{self.host}:{device_info.uuid}")
+        self._capabilities_detected = False
+        return await self._detect_capabilities(force=force)
+
     async def _safe_collect_upnp_description_capabilities(self) -> dict[str, Any]:
         """Collect UPnP description.xml metadata without raising on errors."""
         try:

{pywiim-2.2.1 → pywiim-2.2.3}/pywiim/player/__init__.py

@@ -1210,10 +1210,10 @@ class Player(PlayerBase):
 
     @property
     def supports_subwoofer(self) -> bool:
-        """Whether subwoofer control is supported (WiiM Ultra with firmware 5.2+)."""
+        """Whether subwoofer control is supported (probed via getSubLPF at capability detection)."""
         if not self.client:
             return False
-        return bool(self.client.capabilities.get("supports_subwoofer", False))
+        return self.client.capabilities.get("supports_subwoofer") is True
 
     @property
     def supports_trigger_out(self) -> bool:

{pywiim-2.2.1 → pywiim-2.2.3}/pywiim/player/statemgr.py

@@ -919,34 +919,25 @@ class StateManager:
                 _LOGGER.debug("Failed to fetch Bluetooth history for %s: %s", self.player.host, err)
                 self.player._bluetooth_history = []
 
-        # Subwoofer Status - Fetch on full refresh or periodically (every 60s)
-        # Only available on WiiM Ultra with firmware 5.2+
-        # Subwoofer settings are "set and forget" config, so infrequent polling is fine
-        subwoofer_supported = self.player.client.capabilities.get("supports_subwoofer", None)
+        # Subwoofer status — supports_subwoofer is set in capabilities detection (getSubLPF probe).
+        # Here we only refresh the cached dict when support is True or still unknown (None).
+        subwoofer_supported = self.player.client.capabilities.get("supports_subwoofer")
         should_fetch_subwoofer = full or (
             self._polling_strategy
             and self._polling_strategy.should_fetch_subwoofer(
                 self.player._last_subwoofer_check, subwoofer_supported, now=now
             )
         )
-        # First time: probe to see if subwoofer is supported (subwoofer_supported is None)
-        if should_fetch_subwoofer or subwoofer_supported is None:
+        if should_fetch_subwoofer and subwoofer_supported is not False:
             try:
                 subwoofer_status = await self.player.client.get_subwoofer_status_raw()
                 if subwoofer_status is not None:
                     self.player._subwoofer_status = subwoofer_status
                     self.player._last_subwoofer_check = now
-                    # Mark as supported if we got a valid response
                     if subwoofer_supported is None:
                         self.player.client._capabilities["supports_subwoofer"] = True
-                else:
-                    # API returned None - not supported
-                    if subwoofer_supported is None:
-                        self.player.client._capabilities["supports_subwoofer"] = False
             except Exception as err:
                 _LOGGER.debug("Failed to fetch subwoofer status for %s: %s", self.player.host, err)
-                if subwoofer_supported is None:
-                    self.player.client._capabilities["supports_subwoofer"] = False
 
     async def _finalize_refresh(self) -> None:
         """Finalize refresh: sync group state, propagate metadata, notify callback."""

{pywiim-2.2.1 → pywiim-2.2.3}/pywiim/polling.py

@@ -315,7 +315,7 @@ class PollingStrategy:
 
         Args:
             last_fetch_time: Timestamp of last subwoofer status fetch
-            subwoofer_supported: Whether device supports subwoofer endpoint
+            subwoofer_supported: True if supported, False if not, None if capability probe was inconclusive
             now: Current time (defaults to time.time())
 
         Returns:

{pywiim-2.2.1 → pywiim-2.2.3/pywiim.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pywiim
-Version: 2.2.1
+Version: 2.2.3
 Summary: Python library for WiiM/LinkPlay device communication
 Author-email: Michael Cumming <mjcumming@gmail.com>
 License: MIT