pywiim 2.3.2__tar.gz → 2.3.4__tar.gz

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

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

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

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

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

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

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

@@ -987,12 +987,16 @@ class Player(PlayerBase):
 
     @property
     def queue_count(self) -> int | None:
-        """Total number of tracks in queue (from HTTP API plicount field)."""
+        """Total tracks in queue (HTTP plicount, or PlayQueue overlay)."""
         return self._properties.queue_count
 
     @property
     def queue_position(self) -> int | None:
-        """Current track position in queue (from HTTP API plicurr field)."""
+        """Current queue position (HTTP plicurr, or PlayQueue overlay).
+
+        Overlay is 0-based to match play_queue()/get_queue() item positions.
+        HTTP plicount/plicurr stay 0/empty on the PlayQueue path (ADR 004).
+        """
         return self._properties.queue_position
 
     @property

{pywiim-2.3.2 → pywiim-2.3.4}/pywiim/player/base.py

@@ -148,6 +148,10 @@ class PlayerBase:
         # Last played URL tracking (for media_title fallback)
         self._last_played_url: str | None = None
 
+        # PlayQueue overlay when HTTP plicount/plicurr stay empty (ADR 004)
+        self._playqueue_count: int | None = None
+        self._playqueue_position: int | None = None
+
         # Cover art cache (in-memory, keyed by URL hash)
         # Format: {url_hash: (image_bytes, content_type, timestamp)}
         self._cover_art_cache: dict[str, tuple[bytes, str, float]] = {}

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

@@ -8,6 +8,7 @@ from html import unescape
 from typing import TYPE_CHECKING, Any, Literal
 from xml.etree import ElementTree as ET
 
+from ..api.loop_mode import resolve_loop_mode_mapping_for_player
 from ..exceptions import WiiMError
 from ..upnp.playqueue import (
     CURRENT_QUEUE,
@@ -507,10 +508,76 @@ class MediaControl:
             },
         )
 
+    def _playqueue_loop_mode(self) -> int:
+        """PlayQueue LoopMode: 4 = play through once; map shuffle/repeat when set."""
+        try:
+            mapping = resolve_loop_mode_mapping_for_player(self.player)
+            shuffle = bool(self.player.shuffle_state)
+            repeat = (self.player.repeat_mode or "off").lower()
+            return mapping.to_loop_mode(
+                shuffle=shuffle,
+                repeat_one=repeat == "one",
+                repeat_all=repeat == "all",
+            )
+        except Exception:
+            return 4
+
+    async def _playqueue_apply_loop_mode(self) -> None:
+        """Enable PlayQueue auto-advance via SetQueueLoopMode if advertised."""
+        upnp = self.player._upnp_client
+        if not upnp or not service_has_action(upnp.play_queue, "SetQueueLoopMode"):
+            return
+        mode = self._playqueue_loop_mode()
+        try:
+            await self._playqueue_call("SetQueueLoopMode", {"LoopMode": mode})
+            _LOGGER.debug("Set PlayQueue loop mode %s on %s", mode, self.player.host)
+        except Exception as err:
+            _LOGGER.debug("SetQueueLoopMode failed on %s: %s", self.player.host, err)
+
+    def _playqueue_set_overlay(self, *, count: int | None = None, position: int | None = None) -> None:
+        if count is not None:
+            self.player._playqueue_count = count
+        if position is not None:
+            self.player._playqueue_position = position
+
+    async def _playqueue_sync_overlay(self, *, items: list[dict[str, Any]] | None = None) -> None:
+        """Refresh overlay from GetQueueIndex / BrowseQueue (ADR 004)."""
+        if items is not None:
+            self._playqueue_set_overlay(count=len(items))
+        try:
+            result = await self._playqueue_call("GetQueueIndex", {"QueueName": CURRENT_QUEUE})
+        except Exception as err:
+            _LOGGER.debug("GetQueueIndex overlay failed on %s: %s", self.player.host, err)
+            result = None
+        if result:
+            if items is None:
+                track_nums = result.get("TrackNums")
+                if track_nums is not None:
+                    try:
+                        self._playqueue_set_overlay(count=int(track_nums))
+                    except (TypeError, ValueError):
+                        pass
+            current = result.get("CurrentIndex")
+            if current is not None:
+                try:
+                    idx = int(current)
+                    # CurrentIndex is 1-based
+                    self._playqueue_set_overlay(position=max(idx - 1, 0) if idx > 0 else None)
+                except (TypeError, ValueError):
+                    pass
+        if items is None and self.player._playqueue_count is None:
+            try:
+                result = await self._playqueue_call("BrowseQueue", {"QueueName": CURRENT_QUEUE})
+                parsed = parse_queue_context((result or {}).get("QueueContext", "") or "")
+                self._playqueue_set_overlay(count=len(parsed))
+            except Exception as err:
+                _LOGGER.debug("BrowseQueue overlay failed on %s: %s", self.player.host, err)
+
     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)
+        await self._playqueue_sync_overlay()
         _LOGGER.debug("Added URL to PlayQueue on %s", self.player.host)
 
     async def _playqueue_insert_next(self, url: str, metadata: str = "") -> None:
@@ -525,6 +592,7 @@ class MediaControl:
         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)
+        await self._playqueue_sync_overlay()
         _LOGGER.debug("Inserted URL next in PlayQueue on %s", self.player.host)
 
     async def _playqueue_get(self) -> list[dict[str, Any]]:
@@ -535,6 +603,7 @@ class MediaControl:
             _LOGGER.debug("PlayQueue BrowseQueue empty or failed on %s: %s", self.player.host, err)
             return []
         items = parse_queue_context((result or {}).get("QueueContext", "") or "")
+        await self._playqueue_sync_overlay(items=items)
         _LOGGER.debug("Retrieved %d PlayQueue items from %s", len(items), self.player.host)
         return items
 
@@ -852,6 +921,9 @@ class MediaControl:
                     "PlayQueueWithIndex",
                     {"QueueName": CURRENT_QUEUE, "Index": queue_position + 1},
                 )
+                await self._playqueue_apply_loop_mode()
+                self._playqueue_set_overlay(position=queue_position)
+                await self._playqueue_sync_overlay()
                 _LOGGER.debug(
                     "Started PlayQueue playback at position %d on %s",
                     queue_position,
@@ -925,6 +997,7 @@ class MediaControl:
                         "Action": "",
                     },
                 )
+                await self._playqueue_sync_overlay()
                 _LOGGER.debug(
                     "Removed PlayQueue item at position %d from %s",
                     queue_position,
@@ -984,6 +1057,8 @@ class MediaControl:
         if self._use_playqueue_enqueue():
             try:
                 await self._playqueue_call("DeleteQueue", {"QueueName": CURRENT_QUEUE})
+                self.player._playqueue_count = 0
+                self.player._playqueue_position = None
                 _LOGGER.debug("Cleared PlayQueue on %s", self.player.host)
                 return
             except Exception as err:

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

@@ -480,31 +480,42 @@ class PlayerProperties:
 
         return DEFAULT_WIIM_LOGO_URL
 
-    @property
-    def queue_count(self) -> int | None:
-        """Total number of tracks in queue (from HTTP API plicount field)."""
+    def _http_queue_int(self, field: str) -> int | None:
         if self.player._status_model is None:
             return None
-        count = getattr(self.player._status_model, "queue_count", None)
-        if count is not None:
-            try:
-                return int(count)
-            except (TypeError, ValueError):
-                return None
-        return None
+        value = getattr(self.player._status_model, field, None)
+        if value is None:
+            return None
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            return None
+
+    @property
+    def queue_count(self) -> int | None:
+        """Total tracks in queue (HTTP plicount, or PlayQueue overlay)."""
+        http = self._http_queue_int("queue_count")
+        overlay = self.player._playqueue_count
+        if http:
+            return http
+        if overlay is not None:
+            return overlay
+        return http
 
     @property
     def queue_position(self) -> int | None:
-        """Current track position in queue (from HTTP API plicurr field)."""
-        if self.player._status_model is None:
-            return None
-        position = getattr(self.player._status_model, "queue_position", None)
-        if position is not None:
-            try:
-                return int(position)
-            except (TypeError, ValueError):
-                return None
-        return None
+        """Current queue position (HTTP plicurr, or PlayQueue overlay).
+
+        Overlay is 0-based to match play_queue()/get_queue() item positions.
+        HTTP plicount/plicurr stay 0/empty on the PlayQueue path (ADR 004).
+        """
+        http = self._http_queue_int("queue_position")
+        overlay = self.player._playqueue_position
+        if http:
+            return http
+        if overlay is not None:
+            return overlay
+        return http
 
     @property
     def media_sample_rate(self) -> int | None:

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

@@ -37,6 +37,19 @@ _LOGGER = logging.getLogger(__name__)
 # UPnP retry cooldown - wait this many seconds between failed creation attempts
 UPNP_RETRY_COOLDOWN = 60.0
 
+# Sources where play_url() filename fallback is the intended title.
+# WiiM reports URL playback as custompushurl (display name "URL Stream").
+_URL_PLAYBACK_SOURCES = frozenset({"wifi", "network", "ethernet", "usb", "udisk", "http", "custompushurl"})
+
+
+def _is_url_playback_source(source: Any) -> bool:
+    """Return True for URL/network playback sources (keep play_url filename)."""
+    if source is None:
+        return False
+    key = str(source).strip().lower().replace("-", "_").replace(" ", "_")
+    return key in _URL_PLAYBACK_SOURCES or key in {"wi_fi"}
+
+
 # Standard sources that shouldn't be cleared when checking for multiroom/master names
 STANDARD_SOURCES = {
     "spotify",
@@ -340,9 +353,11 @@ class StateManager:
     async def _refresh_core_status(self) -> PlayerStatus:
         """Fetch core player status and update state synchronizer.
 
-        For slaves in multi-room groups, we use getStatusEx (device status) instead of
-        getPlayerStatusEx. Playback state (track, position, etc.) comes from the master
-        via propagation. We only need volume/mute/group from slaves.
+        For slaves in multi-room groups, we poll the capability-configured status
+        endpoint for volume/mute/group only. Playback state (track, position, etc.)
+        comes from the master via propagation. Volume and mute are written to the
+        state synchronizer so ``Player.volume_level`` / ``is_muted`` reflect device
+        changes (physical buttons, app) on the next poll.
 
         Returns:
             PlayerStatus model from device.
@@ -380,12 +395,18 @@ class StateManager:
                 status = PlayerStatus.model_construct()  # Empty status, fields populated below
 
             # Update volume/mute/group from device status (these are slave-specific)
+            observed_volume = False
+            observed_mute = False
             if "volume" in status_dict:
                 vol = status_dict.get("volume")
                 if vol is not None:
                     status.volume = int(vol) if not isinstance(vol, int) else vol
+                    observed_volume = True
             if "mute" in status_dict:
-                status.mute = status_dict.get("mute")
+                mute_val = status_dict.get("mute")
+                if mute_val is not None:
+                    status.mute = mute_val
+                    observed_mute = True
             if "group" in status_dict:
                 status.group = status_dict.get("group")
 
@@ -402,12 +423,30 @@ class StateManager:
                     mute_from_upnp = await self.player._upnp_client.get_mute()
                     if volume_from_upnp is not None:
                         status.volume = volume_from_upnp
+                        observed_volume = True
                     if mute_from_upnp is not None:
                         status.mute = mute_from_upnp
+                        observed_mute = True
                 except Exception as err:
                     _LOGGER.debug("UPnP GetVolume failed for slave %s: %s", self.player.host, err)
 
             self.player._status_model = status
+
+            # volume_level / is_muted read the synchronizer first. Physical-button
+            # and app changes on a slave only arrive via this poll (HA does not
+            # subscribe to UPnP events), so we must push slave-local volume/mute
+            # without playback/metadata (those stay master-propagated).
+            # Only stamp fields observed this cycle so a missing reading cannot
+            # refresh a stale cache timestamp over a newer UPnP event.
+            # See: https://github.com/mjcumming/wiim/issues/269
+            http_update: dict[str, Any] = {}
+            if observed_volume and status.volume is not None:
+                http_update["volume"] = status.volume
+            if observed_mute and status.mute is not None:
+                http_update["muted"] = status.mute
+            if http_update:
+                self.player._state_synchronizer.update_from_http(http_update)
+
             self.player._last_refresh = time.time()
             self.player._available = True
             return status
@@ -670,8 +709,11 @@ 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
+            # Filename fallback is for URL/network playback. Keep it when
+            # switching *to* wifi/network (play_url just changed the source).
+            # Clear it for physical inputs and other sources (#263).
+            if not _is_url_playback_source(current_source):
+                self.player._last_played_url = None
             if status:
                 status.title = None
                 status.artist = None

{pywiim-2.3.2 → pywiim-2.3.4}/pywiim/state.py

@@ -347,13 +347,6 @@ class StateSynchronizer:
                 timestamp=ts,
             )
 
-        if "duration" in data and not self._is_leftover_after_source_change("duration", data.get("duration")):
-            self._http_state["duration"] = TimestampedField(
-                value=data.get("duration"),
-                source=source,
-                timestamp=ts,
-            )
-
         # Extract volume and mute
         # Only update if value is not None (preserve existing values when API doesn't return volume)
         # This prevents clearing volume when some devices (e.g., Audio Pro) don't return volume
@@ -372,40 +365,14 @@ class StateSynchronizer:
                 timestamp=ts,
             )
 
-        # Extract source — clear track metadata when the input actually changes
-        source_changed = False
-        if "source" in data:
-            new_source = data.get("source")
-            old_field = self._merged_state.source
-            old_source = old_field.value if old_field is not None else None
-            source_changed = self._sources_differ(old_source, new_source)
-            if source_changed:
-                self._remember_stale_metadata(data)
-                self._clear_track_metadata()
-            self._http_state["source"] = TimestampedField(
-                value=new_source,
-                source=source,
-                timestamp=ts,
-            )
-
-        self._release_stale_guard_if_fresh_track(data)
-
-        # Extract metadata (preserve if playing)
-        if not source_changed and (force_metadata_update or not self._should_clear_metadata()):
-            for field_name in ["title", "artist", "album", "image_url"]:
-                if field_name in data:
-                    value = data.get(field_name)
-                    if self._is_leftover_after_source_change(field_name, value):
-                        continue
-                    # Always update if field is present in data (even if None)
-                    # This ensures metadata gets populated when available
-                    # If value is None/empty, we still update to track that HTTP doesn't have it
-                    # (but existing metadata from other sources will be preserved via merge)
-                    self._http_state[field_name] = TimestampedField(
-                        value=value,
-                        source=source,
-                        timestamp=ts,
-                    )
+        # Source first so leftover-guard is set before duration/title are applied.
+        self._apply_source_and_track_fields(
+            data,
+            self._http_state,
+            source,
+            ts,
+            force_metadata_update=force_metadata_update,
+        )
 
         self._merged_state.http_last_update = ts
         self._merge_state()
@@ -445,13 +412,6 @@ class StateSynchronizer:
                 timestamp=ts,
             )
 
-        if "duration" in data and not self._is_leftover_after_source_change("duration", data.get("duration")):
-            self._upnp_state["duration"] = TimestampedField(
-                value=data.get("duration"),
-                source="upnp",
-                timestamp=ts,
-            )
-
         # Extract volume and mute
         if "volume" in data:
             self._upnp_state["volume"] = TimestampedField(
@@ -467,40 +427,13 @@ class StateSynchronizer:
                 timestamp=ts,
             )
 
-        # Extract source — clear track metadata when the input actually changes
-        source_changed = False
-        if "source" in data:
-            new_source = data.get("source")
-            old_field = self._merged_state.source
-            old_source = old_field.value if old_field is not None else None
-            source_changed = self._sources_differ(old_source, new_source)
-            if source_changed:
-                self._remember_stale_metadata(data)
-                self._clear_track_metadata()
-            self._upnp_state["source"] = TimestampedField(
-                value=new_source,
-                source="upnp",
-                timestamp=ts,
-            )
-
-        self._release_stale_guard_if_fresh_track(data)
-
-        # Extract metadata (preserve if playing)
-        if not source_changed and (force_metadata_update or not self._should_clear_metadata()):
-            for field_name in ["title", "artist", "album", "image_url"]:
-                if field_name in data:
-                    value = data.get(field_name)
-                    if self._is_leftover_after_source_change(field_name, value):
-                        continue
-                    # Always update if field is present in data (even if None)
-                    # This ensures metadata gets populated when available
-                    # If value is None/empty, we still update to track that UPnP doesn't have it
-                    # (but existing metadata from other sources will be preserved via merge)
-                    self._upnp_state[field_name] = TimestampedField(
-                        value=value,
-                        source="upnp",
-                        timestamp=ts,
-                    )
+        self._apply_source_and_track_fields(
+            data,
+            self._upnp_state,
+            "upnp",
+            ts,
+            force_metadata_update=force_metadata_update,
+        )
 
         self._merged_state.upnp_last_update = ts
         self._merge_state()
@@ -914,14 +847,72 @@ class StateSynchronizer:
         new_n = str(new).strip().lower().replace("_", "-").replace(" ", "-")
         return bool(old_n and new_n and old_n != new_n)
 
-    def _remember_stale_metadata(self, data: dict[str, Any]) -> None:
-        """Snapshot leftover firmware metadata so later polls cannot re-apply it."""
+    def _apply_source_and_track_fields(
+        self,
+        data: dict[str, Any],
+        dest: dict[str, TimestampedField],
+        source: str,
+        ts: float,
+        *,
+        force_metadata_update: bool,
+    ) -> None:
+        """Apply source, then duration/title so leftover-guard is already set.
+
+        On a source change, snapshot only the *pre-switch* merged track and then
+        still accept incoming fields that are not that leftover. Skipping the
+        transition poll (and snapshotting incoming) hid Spotify title/artist
+        until the next track (wiim #263).
+        """
+        source_changed = False
+        if "source" in data:
+            new_source = data.get("source")
+            old_field = self._merged_state.source
+            old_source = old_field.value if old_field is not None else None
+            source_changed = self._sources_differ(old_source, new_source)
+            if source_changed:
+                self._remember_stale_metadata()
+                self._clear_track_metadata()
+            dest["source"] = TimestampedField(
+                value=new_source,
+                source=source,
+                timestamp=ts,
+            )
+
+        self._release_stale_guard_if_fresh_track(data)
+
+        if "duration" in data and not self._is_leftover_after_source_change("duration", data.get("duration")):
+            dest["duration"] = TimestampedField(
+                value=data.get("duration"),
+                source=source,
+                timestamp=ts,
+            )
+
+        apply_metadata = force_metadata_update or source_changed or not self._should_clear_metadata()
+        if not apply_metadata:
+            return
+        for field_name in ("title", "artist", "album", "image_url"):
+            if field_name not in data:
+                continue
+            value = data.get(field_name)
+            if self._is_leftover_after_source_change(field_name, value):
+                continue
+            dest[field_name] = TimestampedField(
+                value=value,
+                source=source,
+                timestamp=ts,
+            )
+
+    def _remember_stale_metadata(self) -> None:
+        """Snapshot pre-switch merged metadata so later polls cannot re-apply it.
+
+        Incoming values on the same poll may already be the new track
+        (network stream → Spotify) and must not be added to the leftover set.
+        """
         stale: dict[str, set[Any]] = {}
         for field_name in ("title", "artist", "album", "image_url", "duration"):
-            incoming = data.get(field_name)
             merged_field = getattr(self._merged_state, field_name, None)
             merged_val = merged_field.value if merged_field is not None else None
-            values = {v for v in (incoming, merged_val) if v not in (None, "")}
+            values = {v for v in (merged_val,) if v not in (None, "")}
             stale[field_name] = values
         self._stale_metadata_after_source = stale
 

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

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