pywiim 2.2.2__tar.gz → 2.2.4__tar.gz

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

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

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

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

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

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

{pywiim-2.2.2 → pywiim-2.2.4}/pywiim/api/base.py

@@ -930,7 +930,12 @@ class BaseWiiMClient:
         r = await self._request(API_ENDPOINT_STATUS)
         vendor = self._capabilities.get("vendor")
         data = r.parsed if isinstance(r.parsed, dict) else {}
-        parsed, self._last_track = parse_player_status(data, self._last_track, vendor)
+        parsed, self._last_track = parse_player_status(
+            data,
+            self._last_track,
+            vendor,
+            loop_mode_scheme=self._capabilities.get("loop_mode_scheme"),
+        )
         return parsed
 
     async def get_device_info(self) -> dict[str, Any]:
@@ -990,7 +995,12 @@ class BaseWiiMClient:
                     raise primary_err
 
             data = r.parsed if isinstance(r.parsed, dict) else {}
-            parsed, self._last_track = parse_player_status(data, self._last_track, self._capabilities.get("vendor"))
+            parsed, self._last_track = parse_player_status(
+                data,
+                self._last_track,
+                self._capabilities.get("vendor"),
+                loop_mode_scheme=self._capabilities.get("loop_mode_scheme"),
+            )
 
             # If artwork is missing or invalid and device supports getMetaInfo, try to fetch it
             entity_picture = parsed.get("entity_picture")

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

@@ -435,7 +435,9 @@ API_ENDPOINT_TRIGGER_OUT_STATUS = "/httpapi.asp?command=getTriggeroutStatus"
 API_ENDPOINT_TRIGGER_OUT_SET = "/httpapi.asp?command=setTriggeroutStatus:"
 
 # PEQ (Parametric Equalizer) endpoints - official WiiM LV2 PEQ API
-# pluginURI: http://moddevices.com/plugins/caps/EqNp
+# pluginURI (implemented in pywiim): http://moddevices.com/plugins/caps/EqNp
+# Same endpoints also accept other LV2 plugins (e.g. graphic 10-band Eq10HP);
+# pywiim does not implement Eq10HP — see docs/integration/API_REFERENCE.md (PEQ section).
 API_ENDPOINT_PEQ_GET_BAND = "/httpapi.asp?command=EQGetLV2BandEx:"
 API_ENDPOINT_PEQ_GET_SOURCE_BAND = "/httpapi.asp?command=EQGetLV2SourceBandEx:"
 API_ENDPOINT_PEQ_SET_BAND = "/httpapi.asp?command=EQSetLV2Band:"

{pywiim-2.2.2 → pywiim-2.2.4}/pywiim/api/loop_mode.py

@@ -1,16 +1,22 @@
 """Loop mode mappings for different device vendors.
 
-WiiM and Arylic devices use different loop mode value schemes. This module
-provides vendor-specific mappings to handle both correctly.
+WiiM and Arylic devices use different ``loop_mode`` integer schemes. Prefer
+:func:`resolve_loop_mode_mapping` with ``loop_mode_scheme`` from
+:class:`pywiim.profiles.DeviceProfile` — some WiiM firmware (e.g. Ultra 5.2+)
+uses LinkPlay/Arylic numbering while ``vendor`` remains ``wiim``.
+See https://github.com/mjcumming/pywiim/issues/17
 """
 
 from __future__ import annotations
 
-from typing import NamedTuple
+from typing import Any, NamedTuple
 
 __all__ = [
     "LoopModeMapping",
     "get_loop_mode_mapping",
+    "get_loop_mode_mapping_for_scheme",
+    "resolve_loop_mode_mapping",
+    "resolve_loop_mode_mapping_for_player",
     "WIIM_LOOP_MODE",
     "ARYLIC_LOOP_MODE",
 ]
@@ -72,11 +78,6 @@ class LoopModeMapping(NamedTuple):
         if loop_mode == self.normal:
             return (False, False, False)
 
-        # Special case: loop_mode=5 is used by some sources (e.g., Spotify Connect)
-        # when they control playback externally. Treat as normal/unknown state.
-        if loop_mode == 5:
-            return (False, False, False)
-
         # Unknown value - log and return safe default
         import logging
 
@@ -134,8 +135,55 @@ LEGACY_BITFIELD_LOOP_MODE = LoopModeMapping(
 )
 
 
+def get_loop_mode_mapping_for_scheme(scheme: str) -> LoopModeMapping:
+    """Return the mapping table for a profile ``loop_mode_scheme`` value.
+
+    Args:
+        scheme: ``"wiim"``, ``"arylic"``, or ``"legacy"`` (case-insensitive).
+
+    Returns:
+        The corresponding :class:`LoopModeMapping`.
+    """
+    key = (scheme or "wiim").strip().lower()
+    if key == "arylic":
+        return ARYLIC_LOOP_MODE
+    if key == "legacy":
+        return LEGACY_BITFIELD_LOOP_MODE
+    return WIIM_LOOP_MODE
+
+
+def resolve_loop_mode_mapping(
+    *,
+    loop_mode_scheme: str | None = None,
+    vendor: str | None = None,
+) -> LoopModeMapping:
+    """Pick the correct mapping: prefer explicit scheme, then infer from vendor.
+
+    Use this (with ``loop_mode_scheme`` from :func:`pywiim.profiles.get_device_profile`)
+    anywhere shuffle/repeat is translated to or from ``loop_mode`` integers.
+    """
+    if loop_mode_scheme is not None and str(loop_mode_scheme).strip() != "":
+        return get_loop_mode_mapping_for_scheme(loop_mode_scheme)
+    return get_loop_mode_mapping(vendor)
+
+
+def resolve_loop_mode_mapping_for_player(player: Any) -> LoopModeMapping:
+    """Resolve mapping from a :class:`pywiim.player.Player` (profile + client capabilities)."""
+    scheme: str | None = None
+    prof = getattr(player, "profile", None)
+    if prof is not None:
+        scheme = getattr(prof, "loop_mode_scheme", None)
+    if scheme is None:
+        scheme = player.client._capabilities.get("loop_mode_scheme")
+    vendor = player.client._capabilities.get("vendor")
+    return resolve_loop_mode_mapping(loop_mode_scheme=scheme, vendor=vendor)
+
+
 def get_loop_mode_mapping(vendor: str | None) -> LoopModeMapping:
-    """Get the loop mode mapping for a specific vendor.
+    """Infer loop mode mapping from vendor string only (legacy helper).
+
+    Prefer :func:`resolve_loop_mode_mapping` with ``loop_mode_scheme`` from the
+    device profile when model/firmware uses a non-default scheme for this vendor.
 
     Args:
         vendor: Device vendor ("wiim", "arylic", "audio_pro", "linkplay_generic", or None)
@@ -144,7 +192,7 @@ def get_loop_mode_mapping(vendor: str | None) -> LoopModeMapping:
         LoopModeMapping for the vendor
 
     Note:
-        - WiiM devices use sequential values (0,1,2,3,4)
+        - WiiM devices use sequential values (0,1,2,3,4) in the *documented* WiiM scheme
         - Arylic devices use a different sequential scheme (0,1,2,3,4,5)
         - Audio Pro and generic LinkPlay devices default to Arylic mapping
         - Unknown/None vendors default to WiiM mapping (most common)

{pywiim-2.2.2 → pywiim-2.2.4}/pywiim/api/parser.py

@@ -82,7 +82,10 @@ def _normalize_time_value(value: int, field_name: str, source: str | None = None
 
 
 def parse_player_status(
-    raw: dict[str, Any], last_track: str | None = None, vendor: str | None = None
+    raw: dict[str, Any],
+    last_track: str | None = None,
+    vendor: str | None = None,
+    loop_mode_scheme: str | None = None,
 ) -> tuple[dict[str, Any], str | None]:
     """Normalise *getPlayerStatusEx* / *getStatusEx* responses.
 
@@ -92,7 +95,9 @@ def parse_player_status(
     Args:
         raw: Raw API response dictionary
         last_track: Previous track identifier for change detection
-        vendor: Device vendor for vendor-specific loop mode parsing
+        vendor: Device vendor (fallback when ``loop_mode_scheme`` is not set)
+        loop_mode_scheme: Profile scheme ``wiim`` / ``arylic`` / ``legacy`` for ``loop_mode``
+            decode (preferred over vendor alone; see ``get_device_profile``).
 
     Returns:
         Tuple of (parsed_data, new_last_track)
@@ -265,10 +270,9 @@ def parse_player_status(
 
         # Only process play_mode if not already set
         if "play_mode" not in data:
-            # Use vendor-specific loop mode mapping
-            from .loop_mode import get_loop_mode_mapping
+            from .loop_mode import resolve_loop_mode_mapping
 
-            mapping = get_loop_mode_mapping(vendor)
+            mapping = resolve_loop_mode_mapping(loop_mode_scheme=loop_mode_scheme, vendor=vendor)
             is_shuffle, is_repeat_one, is_repeat_all = mapping.from_loop_mode(loop_val)
 
             # Map to play modes
@@ -469,7 +473,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 +481,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.2 → pywiim-2.2.4}/pywiim/api/peq.py

@@ -8,6 +8,11 @@ equalization. Each band has four adjustable parameters:
   - gain:      -12–12 dB
 
 The PEQ is identified by pluginURI ``http://moddevices.com/plugins/caps/EqNp``.
+The same HTTP command family can target other LV2 plugins on the device (for
+example the 10-band graphic plugin ``http://moddevices.com/plugins/caps/Eq10HP``);
+this module implements **only** ``EqNp``.  See ``docs/integration/API_REFERENCE.md``
+(PEQ section) for integrators who need ``Eq10HP``.
+
 All commands operate on a per-source basis (wifi, bluetooth, line-in, etc.).
 
 It assumes the base client provides the ``_request`` coroutine.  No state is

{pywiim-2.2.2 → pywiim-2.2.4}/pywiim/capabilities.py

@@ -9,7 +9,7 @@ The capability detection system uses a multi-layer approach:
 2. Device Type Detection (WiiM vs Legacy)
 3. Firmware Version Detection
 4. Generation Detection (Audio Pro: mkii, w_generation, original)
-5. Endpoint Probing (runtime capability testing)
+5. Endpoint Probing (runtime tests; LED/12V trigger from static model hints, no mutating HTTP at connect)
 6. Protocol Detection (HTTP/HTTPS, ports, client certs)
 
 # pragma: allow-long-file capabilities-cohesive
@@ -37,14 +37,12 @@ from .api.constants import (
     API_ENDPOINT_EQ_STATUS,
     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 .model_names import is_known_wiim_model, is_wiim_12v_trigger_model, is_wiim_ultra
 from .models import DeviceInfo
 from .normalize import normalize_vendor
 from .profiles import detect_audio_pro_generation, detect_vendor, get_device_profile
@@ -448,36 +446,15 @@ class WiiMCapabilities:
 
         capabilities["supports_peq"] = peq_supported
 
-        # Probe for 12V trigger support (WiiM Ultra / Pro / Pro Plus)
-        # getTriggeroutStatus returns {"status":0|1}; only some WiiM models have the hardware
-        try:
-            result = await client._request(API_ENDPOINT_TRIGGER_OUT_STATUS)
-            if isinstance(result.parsed, dict) and "status" in result.parsed:
-                capabilities["supports_trigger_out"] = True
-                _LOGGER.debug(
-                    "Device %s supports 12V trigger (getTriggeroutStatus), result: %s",
-                    client.host,
-                    result.parsed,
-                )
-        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")
-            capabilities["supports_led_switch"] = True
-            _LOGGER.debug("Device %s supports Status Light (LED_SWITCH_SET)", client.host)
-        except WiiMError:
-            _LOGGER.debug("Device %s does not support Status Light (LED_SWITCH_SET)", client.host)
-
         # Get device profile for profile-specific settings (like reboot command)
         # Profile provides device-specific command variations
         # See: https://github.com/mjcumming/wiim/issues/177
         profile = get_device_profile(device_info)
         capabilities["reboot_command"] = profile.endpoints.reboot_command
+        capabilities["loop_mode_scheme"] = profile.loop_mode_scheme
         _LOGGER.debug(
             "Device %s reboot command: %s (from profile %s)",
             client.host,
@@ -554,6 +531,9 @@ def detect_device_capabilities(device_info: DeviceInfo) -> dict[str, Any]:
         - supports_channel_balance: False until runtime probe (WiiM-only); see WiiMCapabilities
         - supports_metadata: Whether device supports metadata
         - status_endpoint: Preferred status endpoint path
+        - supports_led_switch: True for WiiM class (no HTTP probe); absent for non-WiiM until merge defaults
+        - supports_trigger_out: True only for WiiM models with known 12V hardware (Ultra/Pro/Pro Plus)
+        - loop_mode_scheme: Set during runtime ``detect_capabilities`` from ``get_device_profile`` merge
     """
     # Detect and normalize vendor first
     vendor = detect_vendor(device_info)
@@ -593,6 +573,11 @@ def detect_device_capabilities(device_info: DeviceInfo) -> dict[str, Any]:
         capabilities["supports_sleep_timer"] = True  # WiiM devices support sleep timer
         capabilities["max_alarm_slots"] = 3  # WiiM supports 3 independent alarms
         capabilities["supports_firmware_install"] = True  # WiiM devices support firmware update installation via API
+        # Status LED (LED_SWITCH_SET): enable by device class only. Never probe with LED_SWITCH_SET:0
+        # at connect — it turns the LED off (user-visible mutation). See ADR 005 / ADR 016.
+        capabilities["supports_led_switch"] = True
+        # 12V trigger: known hardware (Ultra / Pro / Pro Plus) only — no HTTP probe/toggle at connect.
+        capabilities["supports_trigger_out"] = is_wiim_12v_trigger_model(device_info.model)
         # Display/LCD on/off and brightness (setLightOperationBrightConfig) - WiiM Ultra only
         if is_wiim_ultra(device_info.model):
             capabilities["supports_display_config"] = True

{pywiim-2.2.2 → pywiim-2.2.4}/pywiim/cli/verify_cli.py

@@ -1088,45 +1088,23 @@ class FeatureTester:
                 print(f"   ✗ Error: {e}")
 
     async def test_trigger_out(self) -> None:
-        """Test 12V trigger output (WiiM Ultra / Pro / Pro Plus)."""
+        """Test 12V trigger read path only (no set/toggle — would disturb connected gear)."""
         print("\n⚡ Testing 12V Trigger...")
 
         try:
             if not self.client.capabilities.get("supports_trigger_out", False):
                 self.results["skipped"].append("trigger_out: Not supported")
-                print("   ⊘ 12V trigger not supported (WiiM Ultra/Pro/Pro Plus only)")
+                print("   ⊘ 12V trigger not supported (model class: Ultra / Pro / Pro Plus only)")
                 return
 
             status = await self.client.get_trigger_out_status()
             if status is None:
                 self.results["not_supported"].append("trigger_out: get_trigger_out_status")
-                print("   ⊘ 12V trigger not supported (no response)")
+                print("   ⊘ 12V trigger: get_trigger_out_status returned no value")
                 return
 
-            self.results["passed"].append("trigger_out: get_trigger_out_status")
-            print(f"   ✓ get_trigger_out_status: {'ON' if status else 'OFF'}")
-
-            original_on = status
-            try:
-                await self.client.set_trigger_out(not original_on)
-                await asyncio.sleep(0.3)
-                check = await self.client.get_trigger_out_status()
-                if check is not None and check == (not original_on):
-                    self.results["passed"].append("trigger_out: set_trigger_out")
-                    print(f"   ✓ set_trigger_out({not original_on})")
-                else:
-                    self.results["warnings"].append("trigger_out: set_trigger_out - value not verified")
-                    print("   ⚠️  set_trigger_out - readback not verified")
-                await self.client.set_trigger_out(original_on)
-                await asyncio.sleep(0.2)
-                print(f"   ✓ Restored trigger to {'ON' if original_on else 'OFF'}")
-            except Exception as e:
-                self.results["warnings"].append(f"trigger_out: set_trigger_out - {e}")
-                print(f"   ⚠️  set_trigger_out: {e}")
-                try:
-                    await self.client.set_trigger_out(original_on)
-                except Exception:
-                    pass
+            self.results["passed"].append("trigger_out: get_trigger_out_status (read-only)")
+            print(f"   ✓ get_trigger_out_status: {'ON' if status else 'OFF'} (read-only; set not tested)")
 
         except Exception as e:
             error_str = str(e).lower()

{pywiim-2.2.2 → pywiim-2.2.4}/pywiim/model_names.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import re
 
-__all__ = ["is_known_wiim_model", "is_wiim_ultra", "to_friendly_model_name"]
+__all__ = ["is_known_wiim_model", "is_wiim_ultra", "is_wiim_12v_trigger_model", "to_friendly_model_name"]
 
 # Raw `project` aliases seen on WiiM firmware variants.
 # Keep this list conservative and add entries when confirmed by real devices.
@@ -69,6 +69,36 @@ def is_wiim_ultra(model: str | None) -> bool:
     return key == "wiim_ultra" or (key.startswith("wiim_") and "ultra" in key)
 
 
+# Models known to ship a 12V trigger output (hardware). Do not infer from HTTP at connect:
+# some stacks answer getTriggeroutStatus or accept setTriggeroutStatus without real hardware.
+_WIIM_12V_TRIGGER_EXACT: frozenset[str] = frozenset(
+    {
+        "wiim_ultra",
+        "wiim_pro",
+        "wiim_pro_plus",
+        "wiim_pro_with_gc4a",
+    }
+)
+
+
+def is_wiim_12v_trigger_model(model: str | None) -> bool:
+    """Return True if this WiiM model is expected to have 12V trigger hardware.
+
+    Ultra, Pro, and Pro Plus lines ship the jack. We avoid runtime probing so we
+    never toggle trigger output during capability detection or verification.
+    """
+    key = _normalize_model_key(model)
+    if not key:
+        return False
+    if key in _WIIM_12V_TRIGGER_EXACT:
+        return True
+    if key.startswith("wiim_") and "ultra" in key:
+        return True
+    if key.startswith("wiim_") and "pro_plus" in key:
+        return True
+    return False
+
+
 def to_friendly_model_name(model: str | None) -> str | None:
     """Convert raw project model to branding-friendly name when known."""
     key = _normalize_model_key(model)

{pywiim-2.2.2 → pywiim-2.2.4}/pywiim/player/playback.py

@@ -32,7 +32,7 @@ class PlaybackControl:
         """
         import time
 
-        from ..api.loop_mode import get_loop_mode_mapping
+        from ..api.loop_mode import resolve_loop_mode_mapping_for_player
         from .properties import PlayerProperties
 
         props = PlayerProperties(self.player)
@@ -46,9 +46,7 @@ class PlaybackControl:
                 f"Supported sources: USB, Line In, Optical, Coaxial, Playlist, Preset."
             )
 
-        # Get vendor-specific loop mode mapping
-        vendor = self.player.client._capabilities.get("vendor")
-        mapping = get_loop_mode_mapping(vendor)
+        mapping = resolve_loop_mode_mapping_for_player(self.player)
 
         # Get current repeat state
         repeat_mode = props.repeat_mode
@@ -88,7 +86,7 @@ class PlaybackControl:
         if mode_lower not in ("off", "one", "all"):
             raise ValueError(f"Invalid repeat mode: {mode}. Valid values: 'off', 'one', 'all'")
 
-        from ..api.loop_mode import get_loop_mode_mapping
+        from ..api.loop_mode import resolve_loop_mode_mapping_for_player
         from .properties import PlayerProperties
 
         props = PlayerProperties(self.player)
@@ -102,9 +100,7 @@ class PlaybackControl:
                 f"Supported sources: USB, Line In, Optical, Coaxial, Playlist, Preset."
             )
 
-        # Get vendor-specific loop mode mapping
-        vendor = self.player.client._capabilities.get("vendor")
-        mapping = get_loop_mode_mapping(vendor)
+        mapping = resolve_loop_mode_mapping_for_player(self.player)
 
         # Get current shuffle state
         shuffle_enabled = props.shuffle_state or False

{pywiim-2.2.2 → pywiim-2.2.4}/pywiim/player/properties.py

@@ -687,12 +687,10 @@ class PlayerProperties:
         loop_mode = getattr(self.player._status_model, "loop_mode", None)
         if loop_mode is not None:
             try:
-                from ..api.loop_mode import get_loop_mode_mapping
+                from ..api.loop_mode import resolve_loop_mode_mapping_for_player
 
                 loop_val = int(loop_mode)
-                # Use vendor-specific mapping to interpret loop_mode
-                vendor = self.player.client._capabilities.get("vendor")
-                mapping = get_loop_mode_mapping(vendor)
+                mapping = resolve_loop_mode_mapping_for_player(self.player)
                 shuffle, _, _ = mapping.from_loop_mode(loop_val)
                 return shuffle
             except (TypeError, ValueError):
@@ -731,12 +729,10 @@ class PlayerProperties:
         loop_mode = getattr(self.player._status_model, "loop_mode", None)
         if loop_mode is not None:
             try:
-                from ..api.loop_mode import get_loop_mode_mapping
+                from ..api.loop_mode import resolve_loop_mode_mapping_for_player
 
                 loop_val = int(loop_mode)
-                # Use vendor-specific mapping to interpret loop_mode
-                vendor = self.player.client._capabilities.get("vendor")
-                mapping = get_loop_mode_mapping(vendor)
+                mapping = resolve_loop_mode_mapping_for_player(self.player)
                 _, is_repeat_one, is_repeat_all = mapping.from_loop_mode(loop_val)
 
                 if is_repeat_one:

{pywiim-2.2.2 → pywiim-2.2.4}/pywiim/profiles.py

@@ -30,10 +30,11 @@ from __future__ import annotations
 
 import logging
 import re
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from typing import TYPE_CHECKING, Literal
 
-from .model_names import is_known_wiim_model
+from .api.firmware import compare_firmware_versions
+from .model_names import is_known_wiim_model, is_wiim_ultra
 from .normalize import normalize_vendor
 
 # Firmware version patterns for Audio Pro generation detection.
@@ -470,6 +471,16 @@ def _is_gen1_device(device_info: DeviceInfo) -> bool:
     return False
 
 
+def _wiim_ultra_uses_arylic_loop_mode_scheme(device_info: DeviceInfo) -> bool:
+    """WiiM Ultra on firmware 5.2+ reports LinkPlay/Arylic ``loop_mode`` values (pywiim#17)."""
+    if not is_wiim_ultra(device_info.model):
+        return False
+    fw = device_info.firmware
+    if not fw or not str(fw).strip():
+        return False
+    return compare_firmware_versions(str(fw).strip(), "5.2.0") >= 0
+
+
 def get_device_profile(device_info: DeviceInfo) -> DeviceProfile:
     """Get the appropriate profile for a device.
 
@@ -523,6 +534,13 @@ def get_device_profile(device_info: DeviceInfo) -> DeviceProfile:
     # Other vendors - direct lookup
     profile = PROFILES.get(vendor, PROFILES["linkplay_generic"])
 
+    if vendor == "wiim" and _wiim_ultra_uses_arylic_loop_mode_scheme(device_info):
+        profile = replace(profile, loop_mode_scheme="arylic")
+        _LOGGER.debug(
+            "Device %s: WiiM Ultra firmware uses Arylic loop_mode scheme (pywiim#17)",
+            device_info.name or device_info.model or "?",
+        )
+
     # Check for Gen1 on any device type
     if _is_gen1_device(device_info) and not profile.grouping.uses_wifi_direct:
         _LOGGER.debug(

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

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