Yandex Music: rotor session API, Wave Modes, user presets, library sync improvements

music_assistant/providers/yandex_music/__init__.py

@@ -6,21 +6,26 @@
 
 from music_assistant_models.config_entries import ConfigEntry, ConfigValueOption, ConfigValueType
 from music_assistant_models.enums import ConfigEntryType, ProviderFeature
+from music_assistant_models.errors import InvalidDataError
 
 from .constants import (
+    CONF_ACTION_AUTH_QR,
     CONF_ACTION_CLEAR_AUTH,
     CONF_BASE_URL,
     CONF_LIKED_TRACKS_MAX_TRACKS,
     CONF_MY_WAVE_MAX_TRACKS,
     CONF_QUALITY,
+    CONF_REMEMBER_SESSION,
     CONF_TOKEN,
+    CONF_X_TOKEN,
     DEFAULT_BASE_URL,
     QUALITY_BALANCED,
     QUALITY_EFFICIENT,
     QUALITY_HIGH,
     QUALITY_SUPERB,
 )
 from .provider import YandexMusicProvider
+from .yandex_auth import perform_qr_auth
 
 if TYPE_CHECKING:
     from music_assistant_models.config_entries import ProviderConfig
@@ -55,7 +60,7 @@ async def setup(
 
 
 async def get_config_entries(
-    mass: MusicAssistant,  # noqa: ARG001
+    mass: MusicAssistant,
     instance_id: str | None = None,  # noqa: ARG001
     action: str | None = None,
     values: dict[str, ConfigValueType] | None = None,
@@ -64,33 +69,96 @@ async def get_config_entries(
     if values is None:
         values = {}
 
+    # Handle QR auth action
+    if action == CONF_ACTION_AUTH_QR:
+        session_id = values.get("session_id")
+        if not session_id:
+            raise InvalidDataError("Missing session_id for QR authentication")
+        x_token, music_token = await perform_qr_auth(mass, str(session_id))
+        values[CONF_TOKEN] = music_token
+        if values.get(CONF_REMEMBER_SESSION, True):
+            values[CONF_X_TOKEN] = x_token
+        else:
+            values[CONF_X_TOKEN] = None
+
     # Handle clear auth action
     if action == CONF_ACTION_CLEAR_AUTH:
         values[CONF_TOKEN] = None
+        values[CONF_X_TOKEN] = None
 
     # Check if user is authenticated
     is_authenticated = bool(values.get(CONF_TOKEN))
 
+    # Dynamic label text
+    if not is_authenticated:
+        label_text = (
+            "Scan a QR code with the Yandex app on your phone to authenticate.\n\n"
+            "Alternatively, you can enter a music token manually in the advanced settings."
+        )
+    elif action == CONF_ACTION_AUTH_QR:
+        label_text = "Authenticated to Yandex Music. Don't forget to save to complete setup."
+    else:
+        label_text = "Authenticated to Yandex Music."
+
     return (
-        # Authentication
+        # Status label
         ConfigEntry(
-            key=CONF_TOKEN,
-            type=ConfigEntryType.SECURE_STRING,
-            label="Yandex Music Token",
-            description="Enter your Yandex Music OAuth token. "
-            "See the documentation for how to obtain it.",
-            required=True,
+            key="label_text",
+            type=ConfigEntryType.LABEL,
+            label=label_text,
+        ),
+        # QR authentication (primary)
+        ConfigEntry(
+            key=CONF_ACTION_AUTH_QR,
+            type=ConfigEntryType.ACTION,
+            label="Login with QR code",
+            description="Opens a QR code page — scan it with the Yandex app on your phone.",
+            action=CONF_ACTION_AUTH_QR,
+            action_label="Login with QR code",
+            hidden=is_authenticated,
+        ),
+        # Remember session toggle
+        ConfigEntry(
+            key=CONF_REMEMBER_SESSION,
+            type=ConfigEntryType.BOOLEAN,
+            label="Remember session (auto-refresh token)",
+            description="When enabled, stores a long-lived session token to automatically "
+            "refresh your music token when it expires. When disabled, you must "
+            "re-authenticate manually when the token expires.",
+            default_value=True,
             hidden=is_authenticated,
-            value=cast("str", values.get(CONF_TOKEN)) if values else None,
         ),
+        # Clear auth
         ConfigEntry(
             key=CONF_ACTION_CLEAR_AUTH,
             type=ConfigEntryType.ACTION,
             label="Reset authentication",
             description="Clear the current authentication details.",
             action=CONF_ACTION_CLEAR_AUTH,
+            action_label="Reset authentication",
             hidden=not is_authenticated,
         ),
+        # Manual token entry (advanced fallback)
+        ConfigEntry(
+            key=CONF_TOKEN,
+            type=ConfigEntryType.SECURE_STRING,
+            label="Yandex Music Token (manual)",
+            description="Advanced: manually enter a music token instead of using QR login. "
+            "See the documentation for how to obtain it.",
+            required=False,
+            hidden=is_authenticated,
+            advanced=True,
+            value=cast("str", values.get(CONF_TOKEN)) if values else None,
+        ),
+        # x_token (internal storage, always hidden)
+        ConfigEntry(
+            key=CONF_X_TOKEN,
+            type=ConfigEntryType.SECURE_STRING,
+            label="Session token",
+            hidden=True,
+            required=False,
+            value=cast("str", values.get(CONF_X_TOKEN)) if values else None,
+        ),
         # Quality
         ConfigEntry(
             key=CONF_QUALITY,

music_assistant/providers/yandex_music/api_client.py

@@ -772,10 +772,10 @@ async def _do_request(c: ClientAsync) -> dict[str, Any] | None:
             )
         except Exception as err:
             LOGGER.warning(
-                "get-file-info lossless for track %s: Unexpected error: %s",
+                "get-file-info lossless for track %s: Unexpected %s: %s",
                 track_id,
+                type(err).__name__,
                 err,
-                exc_info=True,
             )
 
         return None

music_assistant/providers/yandex_music/constants.py

@@ -11,8 +11,13 @@
 
 # Actions
 CONF_ACTION_AUTH = "auth"
+CONF_ACTION_AUTH_QR = "auth_qr"
 CONF_ACTION_CLEAR_AUTH = "clear_auth"
 
+# QR authentication config keys
+CONF_X_TOKEN = "x_token"
+CONF_REMEMBER_SESSION = "remember_session"
+
 # Labels
 LABEL_TOKEN = "token_label"
 LABEL_AUTH_INSTRUCTIONS = "auth_instructions_label"

music_assistant/providers/yandex_music/provider.py

@@ -47,6 +47,7 @@
     CONF_LIKED_TRACKS_MAX_TRACKS,
     CONF_MY_WAVE_MAX_TRACKS,
     CONF_TOKEN,
+    CONF_X_TOKEN,
     DEFAULT_BASE_URL,
     DISCOVERY_INITIAL_TRACKS,
     FOR_YOU_FOLDER_ID,
@@ -84,6 +85,7 @@
     parse_track,
 )
 from .streaming import YandexMusicStreamingManager
+from .yandex_auth import refresh_music_token
 
 if TYPE_CHECKING:
     from music_assistant_models.streamdetails import StreamDetails
@@ -157,12 +159,54 @@ def _get_browse_names(self) -> dict[str, str]:
     async def handle_async_init(self) -> None:
         """Handle async initialization of the provider."""
         token = self.config.get_value(CONF_TOKEN)
-        if not token:
-            raise LoginFailed("No Yandex Music token provided")
-
+        x_token = self.config.get_value(CONF_X_TOKEN)
         base_url = self.config.get_value(CONF_BASE_URL, DEFAULT_BASE_URL)
-        self._client = YandexMusicClient(str(token), base_url=str(base_url))
-        await self._client.connect()
+
+        if not token and not x_token:
+            raise LoginFailed("No Yandex Music token provided. Please authenticate.")
+
+        # Try existing music token first (fast path)
+        if token:
+            try:
+                self._client = YandexMusicClient(str(token), base_url=str(base_url))
+                await self._client.connect()
+            except LoginFailed:
+                self.logger.warning("Music token is invalid or expired")
+                # Clear the dead token so restarts go straight to refresh
+                self._update_config_value(CONF_TOKEN, None, encrypted=True)
+                if x_token:
+                    self.logger.info("Attempting to refresh from session token")
+                    token = None
+                    self._client = None
+                else:
+                    raise
+
+        # Refresh from x_token if music token absent or failed
+        if not token and x_token:
+            try:
+                new_music_token = await refresh_music_token(str(x_token))
+                self._update_config_value(CONF_TOKEN, new_music_token, encrypted=True)
+                self._client = YandexMusicClient(new_music_token, base_url=str(base_url))
+                await self._client.connect()
+                self.logger.info("Refreshed music token from session token")
+            except LoginFailed as err:
+                # Definitive auth failure — clear dead credentials
+                self.logger.warning("Session token is invalid or expired")
+                self._update_config_value(CONF_TOKEN, None, encrypted=True)
+                self._update_config_value(CONF_X_TOKEN, None, encrypted=True)
+                raise LoginFailed("Session token expired. Please re-authenticate.") from err
+            except asyncio.CancelledError:
+                raise
+            except Exception as err:
+                # Transient/network failure — keep credentials for retry
+                self.logger.warning(
+                    "Session token refresh failed (network): %s",
+                    type(err).__name__,
+                )
+                raise ProviderUnavailableError(
+                    "Unable to refresh music token right now. Please try again later."
+                ) from err
+
         # Suppress yandex_music library DEBUG dumps (full API request/response JSON)
         logging.getLogger("yandex_music").setLevel(self.logger.level + 10)
         self._streaming = YandexMusicStreamingManager(self)

music_assistant/providers/yandex_music/streaming.py

@@ -547,6 +547,9 @@ async def get_audio_stream(
                         ) from err
 
                     bytes_before = bytes_yielded
+                    # block_skip = bytes re-downloaded for AES-block alignment.
+                    # Needed below to compute actual HTTP bytes received.
+                    block_skip = bytes_before - block_start
                     async for chunk in self._decrypt_response_stream(
                         response, key_bytes, block_size, bytes_yielded
                     ):
@@ -555,7 +558,14 @@ async def get_audio_stream(
 
                     # window complete — check if EOF
                     window_got = bytes_yielded - bytes_before
-                    if response.status == 200 or window_got < _RANGE_WINDOW:
+                    # received = actual HTTP bytes the server sent for this Range
+                    # request.  window_got alone understates the window when
+                    # block_skip > 0 (reconnect at a non-AES-block boundary):
+                    # the decryptor skips block_skip bytes, so window_got would be
+                    # smaller than _RANGE_WINDOW even for a full server response,
+                    # causing premature stream termination without this correction.
+                    received = window_got + block_skip
+                    if response.status == 200 or received < _RANGE_WINDOW:
                         return  # full file received or last partial window
                     # Exact-boundary guard: if file size is an exact multiple of
                     # _RANGE_WINDOW the size check above won't catch EOF.