pywiim 2.3.3__tar.gz → 2.3.4__tar.gz

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

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

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

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

{pywiim-2.3.3 → 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.3"
+__version__ = "2.3.4"
 __all__ = [
     # Main client
     "WiiMClient",

{pywiim-2.3.3 → 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.3 → 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.3 → pywiim-2.3.4/pywiim.egg-info}/PKG-INFO

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