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

music_assistant/providers/yandex_music/__init__.py

@@ -6,21 +6,30 @@
 
 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_CODECS,
     CONF_LIKED_TRACKS_MAX_TRACKS,
     CONF_MY_WAVE_MAX_TRACKS,
     CONF_QUALITY,
+    CONF_REMEMBER_SESSION,
     CONF_TOKEN,
+    CONF_TRANSPORT,
+    CONF_X_TOKEN,
     DEFAULT_BASE_URL,
     QUALITY_BALANCED,
     QUALITY_EFFICIENT,
     QUALITY_HIGH,
     QUALITY_SUPERB,
+    TRANSPORT_ENCRAW,
+    TRANSPORT_RAW,
 )
 from .provider import YandexMusicProvider
+from .yandex_auth import perform_qr_auth
 
 if TYPE_CHECKING:
     from music_assistant_models.config_entries import ProviderConfig
@@ -55,7 +64,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 +73,95 @@ 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,
-            value=cast("str", values.get(CONF_TOKEN)) if values else None,
         ),
+        # 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,
+        ),
+        # 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,
         ),
+        # Token storage (populated by QR action or manual entry)
+        ConfigEntry(
+            key=CONF_TOKEN,
+            type=ConfigEntryType.SECURE_STRING,
+            label="Yandex Music Token",
+            description="Music token — populated automatically by QR login, "
+            "or enter manually. See the documentation for how to obtain it.",
+            required=True,
+            hidden=is_authenticated,
+            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,
@@ -105,6 +176,34 @@ async def get_config_entries(
             ],
             default_value=QUALITY_BALANCED,
         ),
+        # Stream transport (advanced)
+        ConfigEntry(
+            key=CONF_TRANSPORT,
+            type=ConfigEntryType.STRING,
+            label="Stream transport",
+            description="Raw streams directly (recommended). "
+            "Encrypted (encraw) adds AES decryption layer. "
+            "Both use windowed downloads to prevent CDN drops.",
+            options=[
+                ConfigValueOption("Raw (recommended)", TRANSPORT_RAW),
+                ConfigValueOption("Encrypted (encraw)", TRANSPORT_ENCRAW),
+            ],
+            default_value=TRANSPORT_RAW,
+            required=False,
+            advanced=True,
+        ),
+        # Codecs override (advanced)
+        ConfigEntry(
+            key=CONF_CODECS,
+            type=ConfigEntryType.STRING,
+            label="Codecs override",
+            description="Comma-separated codec priority for get-file-info API. "
+            "Leave empty to use the default for your quality setting. "
+            "Example: flac-mp4,flac,aac-mp4,aac,he-aac,mp3,he-aac-mp4",
+            default_value="",
+            required=False,
+            advanced=True,
+        ),
         # My Wave maximum tracks (advanced)
         ConfigEntry(
             key=CONF_MY_WAVE_MAX_TRACKS,

music_assistant/providers/yandex_music/api_client.py

@@ -678,18 +678,31 @@ async def get_track_download_info(
             LOGGER.error("Error fetching download info for track %s: %s", track_id, err)
             return []
 
-    async def get_track_file_info_lossless(self, track_id: str) -> dict[str, Any] | None:
-        """Request lossless stream via get-file-info (quality=lossless).
+    async def get_track_file_info(
+        self,
+        track_id: str,
+        quality: str = "lossless",
+        codecs: str = GET_FILE_INFO_CODECS,
+        transport: str = "raw",
+    ) -> dict[str, Any] | None:
+        """Request stream via get-file-info for any quality tier.
+
+        The /get-file-info endpoint supports all quality tiers (lossless, nq, lq)
+        and returns the best available codec based on the codecs parameter order.
 
-        The /tracks/{id}/download-info endpoint often returns only MP3; get-file-info
-        with quality=lossless and codecs=flac,... returns FLAC when available.
+        With transport="raw", returns a direct unencrypted URL.
+        With transport="encraw", returns an AES-CTR encrypted URL with decryption key.
 
-        Uses manual sign calculation matching yandex-music-downloader-realflac.
         Uses _call_with_retry for automatic reconnection on transient failures.
 
         :param track_id: Track ID.
-        :return: Parsed downloadInfo dict (url, codec, urls, ...) or None on error.
+        :param quality: Quality tier ("lossless", "nq", "lq").
+        :param codecs: Comma-separated codec preference list.
+        :param transport: Transport mode ("raw" or "encraw").
+        :return: Parsed downloadInfo dict (url, codec, key?, ...) or None on error.
         """
+        # Normalize codecs: strip whitespace from each token to prevent HMAC mismatches
+        codecs = ",".join(c.strip() for c in codecs.split(",") if c.strip())
 
         def _build_signed_params(client: ClientAsync) -> tuple[str, dict[str, Any]]:
             """Build URL and signed params using current client and timestamp.
@@ -701,24 +714,20 @@ def _build_signed_params(client: ClientAsync) -> tuple[str, dict[str, Any]]:
             params = {
                 "ts": timestamp,
                 "trackId": track_id,
-                "quality": "lossless",
-                "codecs": GET_FILE_INFO_CODECS,
-                "transports": "encraw",
+                "quality": quality,
+                "codecs": codecs,
+                "transports": transport,
             }
-            # Build sign string explicitly matching Yandex API specification:
-            # concatenate ts + trackId + quality + codecs (commas stripped) + transports.
-            # Comma stripping matches yandex-music-downloader-realflac reference implementation
-            # (see get_file_info signing in that project).
-            codecs_for_sign = GET_FILE_INFO_CODECS.replace(",", "")
-            param_string = f"{timestamp}{track_id}lossless{codecs_for_sign}encraw"
+            # Build sign string: ts + trackId + quality + codecs (commas stripped) + transports.
+            codecs_for_sign = codecs.replace(",", "")
+            param_string = f"{timestamp}{track_id}{quality}{codecs_for_sign}{transport}"
             hmac_sign = hmac.new(
                 DEFAULT_SIGN_KEY.encode(),
                 param_string.encode(),
                 hashlib.sha256,
             )
             # SHA-256 (32 bytes) -> base64 = 44 chars with "=" padding.
             # Yandex API expects exactly 43 chars (one "=" removed).
-            # Matches yandex-music-downloader-realflac reference implementation.
             params["sign"] = base64.b64encode(hmac_sign.digest()).decode()[:-1]
             url = f"{client.base_url}/get-file-info"
             return url, params
@@ -752,30 +761,31 @@ async def _do_request(c: ClientAsync) -> dict[str, Any] | None:
             parsed = _parse_file_info_result(result)
             if parsed:
                 LOGGER.debug(
-                    "get-file-info lossless for track %s: Success, codec=%s",
+                    "get-file-info for track %s: Success, codec=%s, transport=%s",
                     track_id,
                     parsed.get("codec"),
+                    transport,
                 )
                 return parsed
         except (BadRequestError, NetworkError) as err:
             LOGGER.debug(
-                "get-file-info lossless for track %s: %s %s",
+                "get-file-info for track %s: %s %s",
                 track_id,
                 type(err).__name__,
                 getattr(err, "message", str(err)) or repr(err),
             )
         except UnauthorizedError as err:
             LOGGER.debug(
-                "get-file-info lossless for track %s: UnauthorizedError %s",
+                "get-file-info for track %s: UnauthorizedError %s",
                 track_id,
                 getattr(err, "message", str(err)) or repr(err),
             )
         except Exception as err:
             LOGGER.warning(
-                "get-file-info lossless for track %s: Unexpected error: %s",
+                "get-file-info 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"
@@ -28,6 +33,35 @@
 QUALITY_HIGH = "high"  # High quality, lossy (~320kbps MP3)
 QUALITY_SUPERB = "superb"  # Highest quality, lossless (FLAC)
 
+# Transport modes for get-file-info API
+CONF_TRANSPORT = "transport"
+TRANSPORT_RAW = "raw"  # Direct unencrypted stream (default)
+TRANSPORT_ENCRAW = "encraw"  # AES-CTR encrypted stream
+
+# Custom codecs override (empty = use quality-based default)
+CONF_CODECS = "codecs"
+
+# Quality → get-file-info parameter mapping
+# Codecs order determines API priority (first codec = preferred by server)
+QUALITY_FILE_INFO_PARAMS: Final[dict[str, dict[str, str]]] = {
+    QUALITY_SUPERB: {
+        "quality": "lossless",
+        "codecs": "flac-mp4,flac,aac-mp4,aac,he-aac,mp3,he-aac-mp4",
+    },
+    QUALITY_HIGH: {
+        "quality": "lossless",
+        "codecs": "mp3",
+    },
+    QUALITY_BALANCED: {
+        "quality": "nq",
+        "codecs": "aac-mp4,aac,mp3,he-aac,he-aac-mp4",
+    },
+    QUALITY_EFFICIENT: {
+        "quality": "lq",
+        "codecs": "he-aac-mp4,he-aac,aac,mp3",
+    },
+}
+
 # Configuration keys for My Wave behavior (kept)
 CONF_MY_WAVE_MAX_TRACKS: Final[str] = "my_wave_max_tracks"