pywiim 2.2.4__tar.gz → 2.2.5__tar.gz

{pywiim-2.2.4/pywiim.egg-info → pywiim-2.2.5}/PKG-INFO

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

{pywiim-2.2.4 → pywiim-2.2.5}/pyproject.toml

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

{pywiim-2.2.4 → pywiim-2.2.5}/pywiim/__init__.py

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

{pywiim-2.2.4 → pywiim-2.2.5}/pywiim/api/constants.py

@@ -385,6 +385,8 @@ API_ENDPOINT_SET_CHANNEL_BALANCE = "/httpapi.asp?command=setChannelBalance:"
 
 # Miscellaneous endpoints
 API_ENDPOINT_SET_LED = "/httpapi.asp?command=LED_SWITCH_SET:"
+# Read-only status LED state (plain text 0|1 on many WiiM devices; safe at connect — no mutation)
+API_ENDPOINT_GET_LED_SWITCH = "/httpapi.asp?command=LED_SWITCH_GET"
 # Arylic: query LED state via MCU ASCII (getMCUASCIICmd:LED); may not be on all devices
 API_ENDPOINT_GET_LED_MCU = "/httpapi.asp?command=getMCUASCIICmd:LED"
 API_ENDPOINT_SET_BUTTONS = "/httpapi.asp?command=Button_Enable_SET:"

{pywiim-2.2.4 → pywiim-2.2.5}/pywiim/api/misc.py

@@ -22,6 +22,7 @@ from ..exceptions import WiiMError
 from .constants import (
     API_ENDPOINT_DISPLAY_CONFIG,
     API_ENDPOINT_GET_LED_MCU,
+    API_ENDPOINT_GET_LED_SWITCH,
     API_ENDPOINT_SET_BUTTONS,
     API_ENDPOINT_SET_LED,
     API_ENDPOINT_TRIGGER_OUT_SET,
@@ -126,11 +127,21 @@ class MiscAPI:
     # LED Indicator (ADR 005: on/off; read assumes on if unavailable)
     # ------------------------------------------------------------------
 
+    @staticmethod
+    def _parse_led_switch_get_response(raw: str | None, parsed: Any) -> bool | None:
+        """Parse LED_SWITCH_GET (plain 0/1) or similar short text responses."""
+        text = (raw or "").strip()
+        if not text and parsed is not None and not isinstance(parsed, dict):
+            text = str(parsed).strip()
+        if text in ("0", "1"):
+            return text == "1"
+        return None
+
     async def get_led_indicator(self) -> bool:
         """Read LED indicator state from the device.
 
-        Tries getStatusEx (led/LED/led_switch fields) and, for Arylic,
-        getMCUASCIICmd:LED. If read fails or no API exists, returns True
+        Tries LED_SWITCH_GET (read-only on WiiM), getStatusEx led fields, and
+        for Arylic getMCUASCIICmd:LED. If read fails or no API exists, returns True
         (assume on) and logs a warning. No persistent state between sessions.
 
         Returns:
@@ -139,7 +150,20 @@ class MiscAPI:
         caps = getattr(self, "_capabilities", {}) or {}
         vendor = caps.get("vendor", "")
 
-        # 1. Try getStatusEx / get_device_info for led/LED/led_switch
+        # 1. LED_SWITCH_GET — read-only; does not mutate hardware (WiiM Pro/Ultra class)
+        if caps.get("supports_led_switch") or caps.get("is_wiim_device"):
+            try:
+                result = await self._request(API_ENDPOINT_GET_LED_SWITCH)  # type: ignore[attr-defined]
+                state = self._parse_led_switch_get_response(
+                    getattr(result, "raw", None),
+                    getattr(result, "parsed", None),
+                )
+                if state is not None:
+                    return state
+            except WiiMError:
+                pass
+
+        # 2. Try getStatusEx / get_device_info for led/LED/led_switch
         try:
             info = await self.get_device_info()  # type: ignore[attr-defined]
             if isinstance(info, dict):
@@ -157,7 +181,7 @@ class MiscAPI:
         except WiiMError:
             pass
 
-        # 2. Arylic: try getMCUASCIICmd:LED (e.g. response "LED:1" or "LED:0")
+        # 3. Arylic: try getMCUASCIICmd:LED (e.g. response "LED:1" or "LED:0")
         if vendor == "arylic":
             try:
                 result = await self._request(API_ENDPOINT_GET_LED_MCU)  # type: ignore[attr-defined]

{pywiim-2.2.4 → pywiim-2.2.5}/pywiim/cli/monitor_cli.py

@@ -66,6 +66,18 @@ class PlayerMonitor:
         self.last_preset_check = 0.0
         self.last_audio_output_check = 0.0  # Track when to fetch audio output status
         self.last_trigger_out_check = 0.0  # Track when to fetch 12V trigger status
+        self.last_subwoofer_check = 0.0  # Monitor-local subwoofer poll (faster than library tier)
+        self.last_led_indicator_check = 0.0  # Monitor-local status LED poll
+        # Faster than PollingStrategy.CONFIGURATION_INTERVAL (60s) for live testing in this CLI only.
+        self.hardware_poll_interval = 10.0
+
+    def _should_fetch_hardware_status(self, last_fetch_time: float, supported: bool, now: float) -> bool:
+        """Whether to poll trigger/subwoofer/LED (monitor uses shorter interval than player.refresh)."""
+        if not supported:
+            return False
+        if last_fetch_time is None or last_fetch_time == 0:
+            return True
+        return (now - last_fetch_time) >= self.hardware_poll_interval
 
     def _format_source_name(self, source: str) -> str:
         """Format source name for display, handling acronyms correctly.
@@ -98,6 +110,38 @@ class PlayerMonitor:
 
         return " ".join(formatted_words)
 
+    def _format_trigger_out_display(self) -> str | None:
+        """Format 12V trigger line for monitor output, or None if unsupported."""
+        if not self.player.supports_trigger_out:
+            return None
+        trigger_on = self.player.trigger_out_on
+        if trigger_on is True:
+            state_str = "ON"
+        elif trigger_on is False:
+            state_str = "OFF"
+        else:
+            state_str = "unknown"
+        if self.last_trigger_out_check:
+            age = int(time.time() - self.last_trigger_out_check)
+            return f"12V Trigger: {state_str} (read {age}s ago)"
+        return f"12V Trigger: {state_str}"
+
+    def _format_led_indicator_display(self) -> str | None:
+        """Format status LED line for monitor output, or None if unsupported."""
+        if not self.player.supports_led_indicator:
+            return None
+        led_on = self.player.led_indicator_on
+        if led_on is True:
+            state_str = "ON"
+        elif led_on is False:
+            state_str = "OFF"
+        else:
+            state_str = "unknown"
+        if self.last_led_indicator_check:
+            age = int(time.time() - self.last_led_indicator_check)
+            return f"Status LED: {state_str} (read {age}s ago)"
+        return f"Status LED: {state_str}"
+
     def _detect_callback_host(self) -> str | None:
         """Detect the local network IP address for UPnP callback URL.
 
@@ -146,6 +190,12 @@ class PlayerMonitor:
             "shuffle": self.player.shuffle_state,
             "repeat": self.player.repeat_mode,
         }
+        if self.player.supports_trigger_out:
+            current_state["trigger_out"] = self.player.trigger_out_on
+        if self.player.supports_subwoofer:
+            current_state["subwoofer"] = self.player.subwoofer_enabled
+        if self.player.supports_led_indicator:
+            current_state["led_indicator"] = self.player.led_indicator_on
 
         # Track state changes
         if current_state != self.last_state:
@@ -324,6 +374,27 @@ class PlayerMonitor:
         except WiiMError:
             self.last_multiroom = {}  # Request failed, will retry in monitoring loop
 
+        # Initial hardware reads (player.refresh uses ~60s tier; monitor polls faster for testing)
+        now = time.time()
+        if self.player.supports_trigger_out:
+            try:
+                await self.player.get_trigger_out_status()
+                self.last_trigger_out_check = now
+            except Exception:
+                pass
+        if self.player.supports_subwoofer:
+            try:
+                await self.player.get_subwoofer_status()
+                self.last_subwoofer_check = now
+            except Exception:
+                pass
+        if self.player.supports_led_indicator:
+            try:
+                await self.player.get_led_indicator()
+                self.last_led_indicator_check = now
+            except Exception:
+                pass
+
         # Use player.role as source of truth (updated by refresh() via _synchronize_group_state())
         self.previous_role = self.player.role  # Initialize previous_role to avoid false positives
         self.last_group_info_check = time.time()  # Initialize check time
@@ -343,6 +414,19 @@ class PlayerMonitor:
                 print(f"   Vendor: {self.player.client.capabilities.get('vendor', 'unknown')}")
                 if self.player.client.capabilities.get("supports_channel_balance"):
                     print("   Channel balance: HTTP get (refreshed with EQ interval in monitor; no UPnP)")
+                if (
+                    self.player.supports_trigger_out
+                    or self.player.supports_subwoofer
+                    or self.player.supports_led_indicator
+                ):
+                    print(
+                        f"   Hardware poll: trigger/subwoofer/status LED every "
+                        f"{self.hardware_poll_interval:.0f}s (library refresh ~60s)"
+                    )
+                if self.player.supports_trigger_out:
+                    trigger_line = self._format_trigger_out_display()
+                    if trigger_line:
+                        print(f"   {trigger_line}")
                 print(f"   Role: {self.player.role}")
                 print(f"   pywiim: v{__version__}")
 
@@ -534,19 +618,41 @@ class PlayerMonitor:
                             pass  # Don't fail if audio output fetch fails
                     self.last_audio_output_check = now
 
-                # 12V trigger status (same interval as audio output when supported)
-                if self.strategy and self.strategy.should_fetch_audio_output(
+                # 12V trigger + subwoofer (monitor-local fast poll for testing; not library CONFIGURATION_INTERVAL)
+                if self._should_fetch_hardware_status(
                     self.last_trigger_out_check,
-                    False,
-                    self.player.client.capabilities.get("supports_trigger_out", False),
+                    bool(self.player.supports_trigger_out),
                     now,
                 ):
-                    if self.player.client.capabilities.get("supports_trigger_out", False):
-                        try:
-                            await self.player.get_trigger_out_status()
-                        except Exception:
-                            pass
-                    self.last_trigger_out_check = now
+                    try:
+                        status = await self.player.get_trigger_out_status()
+                        if status is not None:
+                            self.last_trigger_out_check = now
+                    except Exception:
+                        pass
+
+                if self._should_fetch_hardware_status(
+                    self.last_subwoofer_check,
+                    bool(self.player.supports_subwoofer),
+                    now,
+                ):
+                    try:
+                        sub = await self.player.get_subwoofer_status()
+                        if sub is not None:
+                            self.last_subwoofer_check = now
+                    except Exception:
+                        pass
+
+                if self._should_fetch_hardware_status(
+                    self.last_led_indicator_check,
+                    bool(self.player.supports_led_indicator),
+                    now,
+                ):
+                    try:
+                        await self.player.get_led_indicator()
+                        self.last_led_indicator_check = now
+                    except Exception:
+                        pass
 
                 # Check for role changes (player.role is updated by refresh() via _synchronize_group_state())
                 role_changed = current_role != old_role
@@ -998,10 +1104,12 @@ class PlayerMonitor:
 
         # ===== HARDWARE (12V TRIGGER / SUBWOOFER) =====
         hardware_parts = []
-        if self.player.supports_trigger_out:
-            trigger_on = self.player.trigger_out_on
-            trigger_str = "ON" if trigger_on else "OFF" if trigger_on is False else "—"
-            hardware_parts.append(f"12V Trigger: {trigger_str}")
+        trigger_line = self._format_trigger_out_display()
+        if trigger_line:
+            hardware_parts.append(trigger_line)
+        led_line = self._format_led_indicator_display()
+        if led_line:
+            hardware_parts.append(led_line)
         if self.player.supports_subwoofer and self.player.subwoofer_status:
             sub = self.player.subwoofer_status
             enabled = sub.get("status", 0) == 1
@@ -1294,6 +1402,17 @@ class PlayerMonitor:
             else:
                 status_parts.append("Bal —")
 
+        trigger_line = self._format_trigger_out_display()
+        if trigger_line:
+            # Compact for single-line mode: "Trigger ON" / "Trigger OFF"
+            compact = trigger_line.replace("12V Trigger: ", "Trigger ").split(" (read")[0]
+            status_parts.append(compact)
+
+        led_line = self._format_led_indicator_display()
+        if led_line:
+            compact_led = led_line.replace("Status LED: ", "LED ").split(" (read")[0]
+            status_parts.append(compact_led)
+
         # Source (capitalize properly)
         source = self.player.source or "none"
         if source != "none":
@@ -1438,6 +1557,12 @@ class PlayerMonitor:
 
         # Device Status
         print("\n📱 Device Status:")
+        trigger_line = self._format_trigger_out_display()
+        if trigger_line:
+            print(f"   • {trigger_line}")
+        led_line = self._format_led_indicator_display()
+        if led_line:
+            print(f"   • {led_line}")
         print(f"   • Available: {'✅' if self.player.available else '❌'}")
         if self.player.device_info:
             print(f"   • Name: {self.player.device_info.name}")
@@ -1470,6 +1595,9 @@ Examples:
 
   # Enable verbose UPnP event logging (shows full event JSON/XML)
   wiim-monitor 192.168.1.68 --upnp-verbose
+
+  # Faster trigger/subwoofer polling while testing against the WiiM app (default 10s)
+  wiim-monitor 192.168.1.68 --hardware-poll 5
         """,
     )
     parser.add_argument(
@@ -1502,6 +1630,14 @@ Examples:
         action="store_true",
         help="Enable verbose UPnP event logging (shows full event JSON/XML data)",
     )
+    parser.add_argument(
+        "--hardware-poll",
+        type=float,
+        default=10.0,
+        metavar="SECONDS",
+        help="Poll 12V trigger, subwoofer, and status LED every N seconds in this CLI (default: 10). "
+        "Does not change library/HA refresh (~60s).",
+    )
 
     args = parser.parse_args()
     device_ip = args.device_ip
@@ -1526,6 +1662,7 @@ Examples:
     monitor.player._on_state_changed = monitor.on_state_changed  # Set callback
     monitor.use_tui = use_tui  # Set TUI mode preference
     monitor.upnp_verbose = args.upnp_verbose  # Set UPnP verbose logging flag
+    monitor.hardware_poll_interval = max(1.0, float(args.hardware_poll))
 
     # Store callback host override for use in setup
     if callback_host_override:

{pywiim-2.2.4 → pywiim-2.2.5}/pywiim/player/__init__.py

@@ -371,12 +371,17 @@ class Player(PlayerBase):
     # === LED Indicator (ADR 005) ===
 
     async def get_led_indicator(self) -> bool:
-        """Read LED indicator state (on/off). Assumes on if device has no read API."""
-        return await self.client.get_led_indicator()
+        """Read LED indicator state (on/off). Updates ``led_indicator_on`` cache."""
+        state = await self.client.get_led_indicator()
+        self._led_indicator_on = state
+        return state
 
     async def set_led_indicator(self, enabled: bool) -> None:
         """Set LED indicator on or off (LED_SWITCH_SET)."""
         await self.client.set_led_switch(enabled)
+        self._led_indicator_on = enabled
+        if self._on_state_changed:
+            self._on_state_changed()
 
     async def get_channel_balance(self) -> float | None:
         """Read stereo channel balance from the device and refresh the player cache.
@@ -1226,10 +1231,20 @@ class Player(PlayerBase):
     def trigger_out_on(self) -> bool | None:
         """Cached 12V trigger state (True=on, False=off, None=unknown).
 
-        Updated when get_trigger_out_status() or set_trigger_out() is called.
+        Updated when get_trigger_out_status() or set_trigger_out() is called, and on
+        configuration-tier refresh during player.refresh() (ADR 019).
         """
         return self._trigger_out_on
 
+    @property
+    def led_indicator_on(self) -> bool | None:
+        """Cached status LED state (True=on, False=off, None=unknown).
+
+        Updated when get_led_indicator() or set_led_indicator() is called, and on
+        configuration-tier refresh when LED_SWITCH_GET is supported.
+        """
+        return self._led_indicator_on
+
     def upnp_health_status(self) -> dict[str, Any] | None:
         """UPnP event health statistics.
 

{pywiim-2.2.4 → pywiim-2.2.5}/pywiim/player/base.py

@@ -119,6 +119,9 @@ class PlayerBase:
         # Only available on WiiM Ultra with firmware 5.2+
         self._subwoofer_status: dict[str, Any] | None = None
         self._trigger_out_on: bool | None = None  # 12V trigger state (None = unknown)
+        self._last_trigger_out_check: float = 0
+        self._led_indicator_on: bool | None = None  # Status LED (None = unknown)
+        self._last_led_indicator_check: float = 0
         self._last_subwoofer_check: float = 0
 
         # Stereo channel balance (-1.0 … 1.0); WiiM HTTP only, gated by supports_channel_balance

{pywiim-2.2.4 → pywiim-2.2.5}/pywiim/player/statemgr.py

@@ -939,6 +939,37 @@ class StateManager:
             except Exception as err:
                 _LOGGER.debug("Failed to fetch subwoofer status for %s: %s", self.player.host, err)
 
+        # 12V trigger — supports_trigger_out from static model (ADR 016/019); configuration-tier read.
+        trigger_out_supported = bool(self.player.client.capabilities.get("supports_trigger_out", False))
+        should_fetch_trigger_out = full or (
+            self._polling_strategy
+            and self._polling_strategy.should_fetch_trigger_out(
+                self.player._last_trigger_out_check, trigger_out_supported, now=now
+            )
+        )
+        if should_fetch_trigger_out and trigger_out_supported:
+            try:
+                trigger_on = await self.player.get_trigger_out_status()
+                if trigger_on is not None:
+                    self.player._last_trigger_out_check = now
+            except Exception as err:
+                _LOGGER.debug("Failed to fetch 12V trigger status for %s: %s", self.player.host, err)
+
+        # Status LED — supports_led_switch from device class (ADR 005); read via LED_SWITCH_GET when available
+        led_supported = bool(self.player.client.capabilities.get("supports_led_switch", False))
+        should_fetch_led = full or (
+            self._polling_strategy
+            and self._polling_strategy.should_fetch_led_indicator(
+                self.player._last_led_indicator_check, led_supported, now=now
+            )
+        )
+        if should_fetch_led and led_supported:
+            try:
+                await self.player.get_led_indicator()
+                self.player._last_led_indicator_check = now
+            except Exception as err:
+                _LOGGER.debug("Failed to fetch LED indicator status for %s: %s", self.player.host, err)
+
     async def _finalize_refresh(self) -> None:
         """Finalize refresh: sync group state, propagate metadata, notify callback."""
         # Synchronize group state from device state

{pywiim-2.2.4 → pywiim-2.2.5}/pywiim/polling.py

@@ -63,7 +63,9 @@ class PollingStrategy:
     # Polling interval constants (in seconds)
     FAST_POLL_INTERVAL = 1.0  # Active Playback / UI Responsiveness
     NORMAL_POLL_INTERVAL = 5.0  # Idle / Background
-    CONFIGURATION_INTERVAL = 60.0  # Bluetooth, EQ, Device Info
+    CONFIGURATION_INTERVAL = 60.0  # Bluetooth, EQ presets, device info
+    # Faster tier for user-toggled hardware (12V trigger, subwoofer) — light GETs, visible in HA/monitor
+    HARDWARE_STATUS_INTERVAL = 15.0
     METADATA_CHECK_INTERVAL = 1.0  # Check for track changes
 
     # Legacy device intervals (longer for older devices)
@@ -334,6 +336,59 @@ class PollingStrategy:
         # Fetch every 60s
         return (now - last_fetch_time) >= self.CONFIGURATION_INTERVAL
 
+    def should_fetch_trigger_out(
+        self,
+        last_fetch_time: float,
+        trigger_out_supported: bool,
+        now: float | None = None,
+    ) -> bool:
+        """Check if 12V trigger status should be fetched.
+
+        Fetch logic:
+        1. On startup (last_fetch_time == 0)
+        2. Every 60s (background consistency)
+        3. Only if device supports 12V trigger (static model class)
+
+        Args:
+            last_fetch_time: Timestamp of last trigger status fetch
+            trigger_out_supported: From capabilities["supports_trigger_out"]
+            now: Current time (defaults to time.time())
+
+        Returns:
+            True if trigger status should be fetched
+        """
+        if not trigger_out_supported:
+            return False
+
+        if now is None:
+            now = time.time()
+
+        if last_fetch_time is None or last_fetch_time == 0:
+            return True
+
+        return (now - last_fetch_time) >= self.CONFIGURATION_INTERVAL
+
+    def should_fetch_led_indicator(
+        self,
+        last_fetch_time: float,
+        led_supported: bool,
+        now: float | None = None,
+    ) -> bool:
+        """Check if status LED (LED indicator) state should be fetched.
+
+        Same cadence as other configuration-tier hardware reads (~60s).
+        """
+        if not led_supported:
+            return False
+
+        if now is None:
+            now = time.time()
+
+        if last_fetch_time is None or last_fetch_time == 0:
+            return True
+
+        return (now - last_fetch_time) >= self.CONFIGURATION_INTERVAL
+
     def should_fetch_device_info(
         self,
         last_fetch_time: float,

{pywiim-2.2.4 → pywiim-2.2.5/pywiim.egg-info}/PKG-INFO

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