pywiim 2.3.0__tar.gz → 2.3.2__tar.gz

{pywiim-2.3.0/pywiim.egg-info → pywiim-2.3.2}/PKG-INFO

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

{pywiim-2.3.0 → pywiim-2.3.2}/pyproject.toml

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

{pywiim-2.3.0 → pywiim-2.3.2}/pywiim/__init__.py

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

{pywiim-2.3.0 → pywiim-2.3.2}/pywiim/api/base.py

@@ -489,7 +489,15 @@ class BaseWiiMClient:
                     except Exception:  # noqa: BLE001
                         pass  # Device info not available, continue without it
 
-                    raise WiiMRequestError(
+                    error_cls = (
+                        WiiMConnectionError
+                        if isinstance(
+                            err,
+                            (aiohttp.ClientConnectorError, aiohttp.ServerDisconnectedError, WiiMConnectionError),
+                        )
+                        else WiiMRequestError
+                    )
+                    raise error_cls(
                         f"Request failed after {retry_count} attempts: {err}",
                         endpoint=endpoint,
                         attempts=retry_count,

{pywiim-2.3.0 → pywiim-2.3.2}/pywiim/api/diagnostics.py

@@ -11,6 +11,21 @@ from .constants import API_ENDPOINT_DEBUG_INFO
 
 _LOGGER = logging.getLogger(__name__)
 
+# Tried after the profile/capability command if the device returns "unknown command".
+# WiiM Amp (and some current WiiM firmware) rejects `reboot` and accepts StartRebootTime:1.
+# Audio Pro devices use StartRebootTime:0.
+_REBOOT_FALLBACKS = ("StartRebootTime:1", "StartRebootTime:0", "reboot")
+
+
+def _is_unknown_reboot_command(resp: Any) -> bool:
+    """Return True when the device rejected the reboot command as unknown."""
+    if resp is None:
+        return False
+    raw = getattr(resp, "raw", None)
+    parsed = getattr(resp, "parsed", None)
+    text = str(raw if raw not in (None, "") else parsed or "").lower()
+    return "unknown command" in text
+
 
 class DiagnosticsAPI:
     """Low-level device maintenance helpers.
@@ -27,51 +42,74 @@ class DiagnosticsAPI:
         even if the device stops responding.
 
         The reboot command varies by device:
-        - WiiM devices: "reboot"
+        - WiiM devices (legacy): "reboot"
+        - WiiM Amp / current WiiM firmware: "StartRebootTime:1"
         - Audio Pro devices: "StartRebootTime:0"
 
-        The correct command is determined from device capabilities/profile.
-        See: https://github.com/mjcumming/wiim/issues/177
+        The first command comes from device capabilities/profile. If the device
+        returns "unknown command", remaining fallbacks are tried and the working
+        command is cached on the client. See: https://github.com/mjcumming/wiim/issues/260
 
         Raises:
             WiiMError: If the request fails before the device reboots.
         """
-        try:
-            # Get reboot command from capabilities (set from device profile)
-            # Default to "reboot" for WiiM and most LinkPlay devices
-            reboot_command = self._capabilities.get("reboot_command", "reboot")  # type: ignore[attr-defined]
-            endpoint = f"/httpapi.asp?command={reboot_command}"
+        primary = self._capabilities.get("reboot_command", "reboot")  # type: ignore[attr-defined]
+        commands: list[str] = [primary]
+        for fallback in _REBOOT_FALLBACKS:
+            if fallback not in commands:
+                commands.append(fallback)
+
+        last_err: Exception | None = None
+        for command in commands:
+            endpoint = f"/httpapi.asp?command={command}"
+            _LOGGER.debug("Sending reboot command: %s", command)
+            try:
+                resp = await self._request_reboot(endpoint)
+            except Exception as err:
+                last_err = err
+                error_str = str(err).lower()
+                if "unknown command" in error_str:
+                    _LOGGER.debug("Reboot command %s not supported, trying fallback", command)
+                    continue
+                # Connection drop / empty body: command was likely accepted
+                _LOGGER.info("Reboot command sent to device (device may not respond): %s", err)
+                return
 
-            _LOGGER.debug("Sending reboot command: %s", reboot_command)
+            if _is_unknown_reboot_command(resp):
+                _LOGGER.debug("Reboot command %s returned unknown command, trying fallback", command)
+                continue
 
-            # Send reboot command - device may not respond after this
-            # Use a custom request method that handles empty responses gracefully
-            await self._request_reboot(endpoint)
-        except Exception as err:
-            # Reboot commands often don't return proper responses
-            # Log the attempt but don't fail the service call
-            _LOGGER.info("Reboot command sent to device (device may not respond): %s", err)
-            # Don't re-raise - reboot command was sent successfully
+            if command != primary:
+                self._capabilities["reboot_command"] = command  # type: ignore[attr-defined]
+                _LOGGER.info("Reboot command %s succeeded; cached for this device", command)
+            return
+
+        if last_err:
+            _LOGGER.info("Reboot command sent to device (device may not respond): %s", last_err)
 
-    async def _request_reboot(self, endpoint: str) -> None:
+    async def _request_reboot(self, endpoint: str) -> Any:
         """Special request method for reboot that handles empty responses gracefully.
 
         Args:
             endpoint: The reboot endpoint to call.
 
+        Returns:
+            ApiResponse from the device, or None when the device dropped the
+            connection after accepting the command.
+
         Raises:
             WiiMError: If the request fails for reasons other than expected reboot behavior.
         """
         try:
             # Try to send the reboot command
-            await self._request(endpoint)  # type: ignore[attr-defined]
+            return await self._request(endpoint)  # type: ignore[attr-defined]
         except Exception as err:
             # If the request fails due to parsing issues (common with reboot),
             # we still consider it successful since the command was sent
             error_str = str(err).lower()
             if any(x in error_str for x in ["expecting value", "json decode", "empty response"]):
                 _LOGGER.info("Reboot command sent successfully (device stopped responding as expected)")
-                return
+                return None
             else:
                 # Re-raise other types of errors
                 raise

{pywiim-2.3.0 → pywiim-2.3.2}/pywiim/player/__init__.py

@@ -522,6 +522,22 @@ class Player(PlayerBase):
         if self._on_state_changed:
             self._on_state_changed()
 
+    async def set_main_speaker_bass(self, enabled: bool) -> None:
+        """Enable or disable bass output to the main speakers.
+
+        When disabled, frequencies below the crossover go only to the subwoofer.
+        When enabled, bass is also sent to the main speakers.
+
+        Args:
+            enabled: True to send bass to main speakers, False to filter it out.
+        """
+        await self.client.set_main_speaker_bass(enabled)
+        if self._subwoofer_status:
+            # API uses inverted logic: main_filter=1 means bass filtered from mains
+            self._subwoofer_status["main_filter"] = 0 if enabled else 1
+        if self._on_state_changed:
+            self._on_state_changed()
+
     # === Display (WiiM Ultra; ADR 005) ===
 
     async def set_display_enabled(
@@ -1234,6 +1250,20 @@ class Player(PlayerBase):
             return False
         return self.client.capabilities.get("supports_subwoofer") is True
 
+    @property
+    def main_speaker_bass(self) -> bool | None:
+        """Whether bass is sent to the main speakers.
+
+        Returns:
+            True if mains receive bass, False if the main-speaker bass filter
+            is active, None if subwoofer status has not been read.
+        """
+        if self._subwoofer_status is None:
+            return None
+        if "main_filter" not in self._subwoofer_status:
+            return None
+        return int(self._subwoofer_status.get("main_filter", 0)) == 0
+
     @property
     def supports_trigger_out(self) -> bool:
         """Whether 12V trigger output is supported (WiiM Ultra / Pro / Pro Plus)."""
@@ -1377,18 +1407,19 @@ class Player(PlayerBase):
 
     @property
     def supports_queue_browse(self) -> bool:
-        """Whether full queue retrieval is available (UPnP ContentDirectory).
+        """Whether full queue retrieval is available.
 
-        Only available on WiiM Amp and Ultra when a USB drive is connected.
-        Most WiiM devices (Mini, Pro, Pro Plus) do not support this.
+        True for ContentDirectory (Amp/Ultra + USB) or PlayQueue BrowseQueue
+        (WiiM Pro / Pro Plus after a queue has been created).
         """
         return self._properties.supports_queue_browse
 
     @property
     def supports_queue_add(self) -> bool:
-        """Whether adding items to queue is supported (UPnP AVTransport).
+        """Whether adding items to queue is supported.
 
-        Available on most devices with UPnP support.
+        True for AVTransport AddURIToQueue or PlayQueue
+        CreateQueue/AppendTracksInQueueEx/PlayQueueWithIndex.
         """
         return self._properties.supports_queue_add
 

{pywiim-2.3.0 → pywiim-2.3.2}/pywiim/player/media.py

@@ -9,6 +9,14 @@ from typing import TYPE_CHECKING, Any, Literal
 from xml.etree import ElementTree as ET
 
 from ..exceptions import WiiMError
+from ..upnp.playqueue import (
+    CURRENT_QUEUE,
+    build_empty_playlist,
+    build_track_playlist,
+    parse_queue_context,
+    playqueue_supports_enqueue,
+    service_has_action,
+)
 from .source_capabilities import SOURCE_CAPABILITIES, source_supports_native_notification_prompt
 
 if TYPE_CHECKING:
@@ -175,9 +183,9 @@ class MediaControl:
         # Call API (raises on failure)
         await self.player.client.stop()
 
-        # Update cached state immediately (optimistic)
+        # Update cached state immediately (optimistic). "stop" normalizes to idle.
         if self.player._status_model:
-            self.player._status_model.play_state = "stop"
+            self.player._status_model.play_state = "idle"
 
         # Update state synchronizer (for immediate property reads)
         self.player._state_synchronizer.update_from_http({"play_state": "stop"})
@@ -393,9 +401,20 @@ class MediaControl:
 
         return result
 
+    def _use_playqueue_enqueue(self) -> bool:
+        """Prefer vendor PlayQueue when AVTransport has no AddURIToQueue."""
+        upnp = self.player._upnp_client
+        if not upnp:
+            return False
+        if service_has_action(upnp.av_transport, "AddURIToQueue"):
+            return False
+        return playqueue_supports_enqueue(upnp.play_queue)
+
     async def add_to_queue(self, url: str, metadata: str = "") -> None:
         """Add URL to end of queue (requires UPnP client).
 
+        Uses PlayQueue on WiiM firmware that lacks AVTransport AddURIToQueue.
+
         Args:
             url: URL to add to queue.
             metadata: Optional DIDL-Lite metadata.
@@ -403,6 +422,10 @@ class MediaControl:
         if not self.player._upnp_client:
             raise WiiMError("Queue management requires UPnP client.")
 
+        if self._use_playqueue_enqueue():
+            await self._playqueue_add(url, metadata)
+            return
+
         await self.player._upnp_client.async_call_action(
             "AVTransport",
             "AddURIToQueue",
@@ -425,6 +448,10 @@ class MediaControl:
         if not self.player._upnp_client:
             raise WiiMError("Queue management requires UPnP client.")
 
+        if self._use_playqueue_enqueue():
+            await self._playqueue_insert_next(url, metadata)
+            return
+
         await self.player._upnp_client.async_call_action(
             "AVTransport",
             "InsertURIToQueue",
@@ -443,6 +470,74 @@ class MediaControl:
         elif enqueue == "next":
             await self.insert_next(url)
 
+    async def _playqueue_call(self, action: str, arguments: dict[str, Any]) -> dict[str, Any]:
+        """Call a PlayQueue action."""
+        upnp = self.player._upnp_client
+        if not upnp:
+            raise WiiMError("Queue management requires UPnP client.")
+        return await upnp.async_call_action("play_queue", action, arguments)
+
+    async def _playqueue_ensure(self) -> None:
+        """Create CurrentQueue if BrowseQueue says it does not exist."""
+        try:
+            await self._playqueue_call("BrowseQueue", {"QueueName": CURRENT_QUEUE})
+        except Exception:
+            await self._playqueue_call(
+                "CreateQueue",
+                {"QueueContext": build_empty_playlist()},
+            )
+
+    async def _playqueue_append(
+        self,
+        url: str,
+        metadata: str = "",
+        *,
+        start_index: int = 0,
+        play: int = 0,
+    ) -> None:
+        """Append one track via AppendTracksInQueueEx."""
+        await self._playqueue_call(
+            "AppendTracksInQueueEx",
+            {
+                "QueueContext": build_track_playlist(url, metadata),
+                "Direction": 1,
+                "StartIndex": start_index,
+                "Play": play,
+                "Action": "",
+            },
+        )
+
+    async def _playqueue_add(self, url: str, metadata: str = "") -> None:
+        """Add URL to the end of CurrentQueue without starting playback."""
+        await self._playqueue_ensure()
+        await self._playqueue_append(url, metadata)
+        _LOGGER.debug("Added URL to PlayQueue on %s", self.player.host)
+
+    async def _playqueue_insert_next(self, url: str, metadata: str = "") -> None:
+        """Insert URL after the current PlayQueue index."""
+        await self._playqueue_ensure()
+        start_index = 1
+        try:
+            result = await self._playqueue_call("GetQueueIndex", {"QueueName": CURRENT_QUEUE})
+            current = result.get("CurrentIndex")
+            if current is not None:
+                start_index = int(current)
+        except Exception as err:
+            _LOGGER.debug("GetQueueIndex failed on %s, appending after index 1: %s", self.player.host, err)
+        await self._playqueue_append(url, metadata, start_index=start_index)
+        _LOGGER.debug("Inserted URL next in PlayQueue on %s", self.player.host)
+
+    async def _playqueue_get(self) -> list[dict[str, Any]]:
+        """Browse CurrentQueue and parse Track entries."""
+        try:
+            result = await self._playqueue_call("BrowseQueue", {"QueueName": CURRENT_QUEUE})
+        except Exception as err:
+            _LOGGER.debug("PlayQueue BrowseQueue empty or failed on %s: %s", self.player.host, err)
+            return []
+        items = parse_queue_context((result or {}).get("QueueContext", "") or "")
+        _LOGGER.debug("Retrieved %d PlayQueue items from %s", len(items), self.player.host)
+        return items
+
     async def play_preset(self, preset: int, index: int | None = None) -> None:
         """Play a preset by number, optionally starting at a track index.
 
@@ -705,6 +800,9 @@ class MediaControl:
         if not self.player._upnp_client:
             raise WiiMError("Queue retrieval requires UPnP client.")
 
+        if self._use_playqueue_enqueue():
+            return await self._playqueue_get()
+
         try:
             # Browse queue using ContentDirectory service
             result = await self.player._upnp_client.browse_queue(
@@ -748,6 +846,27 @@ class MediaControl:
         if queue_position < 0:
             raise WiiMError(f"Invalid queue position: {queue_position} (must be >= 0)")
 
+        if self._use_playqueue_enqueue():
+            try:
+                await self._playqueue_call(
+                    "PlayQueueWithIndex",
+                    {"QueueName": CURRENT_QUEUE, "Index": queue_position + 1},
+                )
+                _LOGGER.debug(
+                    "Started PlayQueue playback at position %d on %s",
+                    queue_position,
+                    self.player.host,
+                )
+                return
+            except Exception as err:
+                _LOGGER.warning(
+                    "Failed to play PlayQueue position %d on %s: %s",
+                    queue_position,
+                    self.player.host,
+                    err,
+                )
+                raise WiiMError(f"Failed to play queue position {queue_position}: {err}") from err
+
         try:
             # Use Seek with TRACK_NR unit to jump to queue position
             # UPnP uses 1-based track numbers, so add 1 to 0-based position
@@ -794,6 +913,33 @@ class MediaControl:
         if queue_position < 0:
             raise WiiMError(f"Invalid queue position: {queue_position} (must be >= 0)")
 
+        if self._use_playqueue_enqueue():
+            index = queue_position + 1
+            try:
+                await self._playqueue_call(
+                    "RemoveTracksInQueue",
+                    {
+                        "QueueName": CURRENT_QUEUE,
+                        "RangStart": index,
+                        "RangEnd": index,
+                        "Action": "",
+                    },
+                )
+                _LOGGER.debug(
+                    "Removed PlayQueue item at position %d from %s",
+                    queue_position,
+                    self.player.host,
+                )
+                return
+            except Exception as err:
+                _LOGGER.warning(
+                    "Failed to remove PlayQueue position %d on %s: %s",
+                    queue_position,
+                    self.player.host,
+                    err,
+                )
+                raise WiiMError(f"Failed to remove queue position {queue_position}: {err}") from err
+
         try:
             # RemoveTrackFromQueue uses ObjectID which is typically "Q:0/position"
             # UPnP uses 1-based track numbers
@@ -835,6 +981,15 @@ class MediaControl:
         if not self.player._upnp_client:
             raise WiiMError("Queue management requires UPnP client.")
 
+        if self._use_playqueue_enqueue():
+            try:
+                await self._playqueue_call("DeleteQueue", {"QueueName": CURRENT_QUEUE})
+                _LOGGER.debug("Cleared PlayQueue on %s", self.player.host)
+                return
+            except Exception as err:
+                _LOGGER.warning("Failed to clear PlayQueue on %s: %s", self.player.host, err)
+                raise WiiMError(f"Failed to clear queue: {err}") from err
+
         try:
             await self.player._upnp_client.async_call_action(
                 "av_transport",

{pywiim-2.3.0 → pywiim-2.3.2}/pywiim/player/properties.py

@@ -9,6 +9,7 @@ from ..device_capabilities import filter_plm_inputs, get_device_inputs
 from ..metadata import is_valid_image_url, is_valid_metadata_value
 from ..normalize import HARDWARE_SOURCE_KEYS as _HARDWARE_SOURCE_KEYS
 from ..normalize import canonical_source_key, source_rename_reverse
+from ..upnp.playqueue import playqueue_supports_enqueue, service_has_action
 from .source_capabilities import SourceCapability, get_source_capabilities
 
 if TYPE_CHECKING:
@@ -184,12 +185,10 @@ class PlayerProperties:
         Returns True when device has no active media. This indicates the device
         is not playing and has no media to resume.
 
-        Note: "stop" states are normalized to "pause" (modern UX), so stopped
-        devices are considered paused, not idle. Use is_paused to check for
-        both paused and stopped states.
+        Note: HTTP/UPnP "stop" and "stopped" normalize to idle.
         """
         state = self.play_state
-        return state is None or state in ("idle", "none")
+        return state is None or state in ("idle", "none", "stop", "stopped")
 
     @property
     def is_buffering(self) -> bool:
@@ -239,11 +238,22 @@ class PlayerProperties:
     # === Media Metadata ===
 
     def _status_field(self, *names: str) -> str | None:
-        """Return the first non-empty attribute from merged state or cached status."""
-        # First try merged state (combines HTTP + UPnP)
-        merged = self.player._state_synchronizer.get_merged_state()
+        """Return the first non-empty attribute from merged state or cached status.
+
+        Only fall back to the raw cached status for names the synchronizer has
+        never resolved. If it resolved a name to no value (live stream, source
+        change), that decision must not be overridden by leftover firmware
+        fields still sitting on ``_status_model`` (wiim #263).
+        """
+        state_obj = self.player._state_synchronizer.get_state_object()
+        names_unresolved_by_synchronizer: list[str] = []
         for n in names:
-            val = merged.get(n)
+            field = getattr(state_obj, n, None)
+            if field is None:
+                names_unresolved_by_synchronizer.append(n)
+                continue
+
+            val = field.value
             if val is not None:
                 # Field-aware filtering: artwork fields must be valid URLs,
                 # other metadata must be non-placeholder values.
@@ -270,11 +280,18 @@ class PlayerProperties:
                 if val not in (None, ""):
                     return str(val) if val is not None else None
 
-        # Fallback to cached status if synchronizer has no data yet
-        if self.player._status_model is None:
+        # Fallback to cached status only before the first merge. After that the
+        # raw status model is a leftover firmware snapshot and must not reopen
+        # fields the synchronizer already decided are empty (wiim #263).
+        if (
+            self.player._status_model is None
+            or not names_unresolved_by_synchronizer
+            or state_obj.http_last_update is not None
+            or state_obj.upnp_last_update is not None
+        ):
             return None
 
-        for n in names:
+        for n in names_unresolved_by_synchronizer:
             if hasattr(self.player._status_model, n):
                 val = getattr(self.player._status_model, n)
                 if n in {"image_url", "entity_picture", "cover_url"}:
@@ -311,6 +328,11 @@ class PlayerProperties:
         if title:
             return title
 
+        # URL filename is only a stand-in for URL playback. Hardware inputs and
+        # idle/stop must not keep showing the last play_url() filename (#263).
+        if self.is_idle or self._is_physical_input_source():
+            return None
+
         # Fallback: extract filename from last played URL
         url = self.player._last_played_url
         if url:
@@ -335,6 +357,26 @@ class PlayerProperties:
 
         return None
 
+    def _is_physical_input_source(self) -> bool:
+        """Return True for passthrough inputs that never use play_url() metadata."""
+        source = (self.source or "").strip().lower().replace("-", "_")
+        return source in {
+            "line_in",
+            "linein",
+            "optical",
+            "coaxial",
+            "coax",
+            "aux",
+            "hdmi",
+            "phono",
+            "rca",
+            "line_in_2",
+            "linein_2",
+            "bluetooth",
+            "usb_dac",
+            "usbdac",
+        }
+
     @property
     def media_artist(self) -> str | None:
         """Current track artist from cached status."""
@@ -1713,24 +1755,31 @@ class PlayerProperties:
 
     @property
     def supports_queue_browse(self) -> bool:
-        """Whether full queue retrieval is available (UPnP ContentDirectory).
+        """Whether full queue retrieval is available.
 
-        Only available on WiiM Amp and Ultra when a USB drive is connected.
-        Most WiiM devices (Mini, Pro, Pro Plus) do not support this.
+        True when ContentDirectory is present (Amp/Ultra + USB) or when the
+        vendor PlayQueue service can BrowseQueue (WiiM Pro / Pro Plus).
         """
         if not self.player._upnp_client:
             return False
-        return self.player._upnp_client.content_directory is not None
+        if self.player._upnp_client.content_directory is not None:
+            return True
+        return service_has_action(self.player._upnp_client.play_queue, "BrowseQueue")
 
     @property
     def supports_queue_add(self) -> bool:
-        """Whether adding items to queue is supported (UPnP AVTransport).
+        """Whether adding items to queue is supported.
 
-        Available on most devices with UPnP support.
+        True when AVTransport advertises ``AddURIToQueue`` (Sonos-style) or
+        when PlayQueue advertises CreateQueue + AppendTracksInQueueEx +
+        PlayQueueWithIndex (WiiM Pro / Pro Plus). Presence of AVTransport
+        alone is not enough.
         """
         if not self.player._upnp_client:
             return False
-        return self.player._upnp_client.av_transport is not None
+        if service_has_action(self.player._upnp_client.av_transport, "AddURIToQueue"):
+            return True
+        return playqueue_supports_enqueue(self.player._upnp_client.play_queue)
 
     @property
     def supports_queue_count(self) -> bool:

{pywiim-2.3.0 → pywiim-2.3.2}/pywiim/player/statemgr.py

@@ -670,6 +670,13 @@ class StateManager:
             self._last_source = current_source
         elif source_changed:
             self._last_source = current_source
+            # play_url() filename fallback must not survive a source switch (#263)
+            self.player._last_played_url = None
+            if status:
+                status.title = None
+                status.artist = None
+                status.album = None
+                status.duration = None
 
         # Check if we need to enrich metadata (title/artist are Unknown - common with Bluetooth AVRCP)
         status_title = status.title if status else None