SpotiFLAC 4.2.2__tar.gz → 4.3.0__tar.gz

{spotiflac-4.2.2/SpotiFLAC.egg-info → spotiflac-4.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SpotiFLAC
-Version: 4.2.2
+Version: 4.3.0
 Summary: Fetch Spotify track metadata and retrieve matching lossless audio through configurable Tidal, Qobuz & Amazon Music provider backends.
 Author:  BartolomeoRusso9
 License: MIT

{spotiflac-4.2.2 → spotiflac-4.3.0}/SpotiFLAC/core/health_check.py

@@ -21,6 +21,13 @@ _SERVERS = {
     "qq": "https://lyrics.paxsenix.org/qq/search?q=Bohemian%20Rhapsody%20Queen",
     "youtube": "https://lyrics.paxsenix.org/youtube/search?q=Bohemian%20Rhapsody%20Queen",
     "kugou": "https://lyrics.paxsenix.org/kugou/search?q=Bohemian%20Rhapsody%20Queen",
+    "binilyrics": "https://lyrics-api.binimum.org/?track=Bohemian%20Rhapsody&artist=Queen&duration=355",
+    # Unison answers 404 for anything it has no lyrics for, and it has few:
+    # this is a track it does have.
+    "unison": "https://unison.boidu.dev/lyrics?song=Someone%20Like%20You&artist=Adele&duration=285",
+    # "Tum Hi Ho" (id aRZbUYD7): one of the has_lyrics:true results, so this
+    # actually exercises the lyrics.getLyrics call, not just search.
+    "jiosaavn": "https://www.jiosaavn.com/api.php?__call=lyrics.getLyrics&_format=json&_marker=0&api_version=4&ctx=web6dot0&lyrics_id=aRZbUYD7",
 }
 
 

{spotiflac-4.2.2 → spotiflac-4.3.0}/SpotiFLAC/core/lyrics.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import html
 import logging
 import os
 import re
@@ -42,7 +43,7 @@ class LyricsContext:
         return get_primary_artist(self.artist_name)
 
 
-DEFAULT_LYRICS_PROVIDERS = ["apple", "lrclib"]
+DEFAULT_LYRICS_PROVIDERS = ["apple", "lrclib", "binilyrics", "unison"]
 DEFAULT_ENRICH_PROVIDERS = ["deezer", "apple", "qobuz", "tidal"]
 
 
@@ -214,7 +215,13 @@ async def _get_spotify_anon_token(timeout: int = 7) -> str:
         try:
             client = await NetworkManager.get_async_client_safe()
 
-            totp_headers: dict[str, str] = {}
+            # Spotify wants the TOTP as query parameters, the way
+            # spotfetch.py sends it. Sent as headers the endpoint answers
+            # 400 "Unauthorized request" and there is no token at all.
+            params = {
+                "reason": "init",
+                "productType": "web-player",
+            }
 
             try:
                 from .spotify_totp import generate_spotify_totp
@@ -222,8 +229,9 @@ async def _get_spotify_anon_token(timeout: int = 7) -> str:
                 code, version = generate_spotify_totp()
 
                 if code:
-                    totp_headers["Spotify-TOTP"] = code
-                    totp_headers["Spotify-TOTP-V2"] = f"{code}:{version}"
+                    params["totp"] = code
+                    params["totpVer"] = str(version)
+                    params["totpServer"] = code
 
             except Exception:
                 pass
@@ -236,14 +244,8 @@ async def _get_spotify_anon_token(timeout: int = 7) -> str:
 
             r = await client.get(
                 "https://open.spotify.com/api/token",
-                params={
-                    "reason": "init",
-                    "productType": "web-player",
-                },
-                headers={
-                    "User-Agent": _UA,
-                    **totp_headers,
-                },
+                params=params,
+                headers={"User-Agent": _UA},
                 timeout=timeout,
             )
 
@@ -932,6 +934,275 @@ async def _fetch_lrclib_async(
     return ""
 
 
+# ---------------------------------------------------------------------------
+# Apple-TTML catalogues: BiniLyrics, Unison
+# ---------------------------------------------------------------------------
+
+_BINI_API = "https://lyrics-api.binimum.org/"
+_UNISON_API = "https://unison.boidu.dev/lyrics"
+
+#: A recording is only taken when its length is this close to the track's, so
+#: the words fall on the same beat. Both catalogues search by name, and a live
+#: or sped-up cut of the same song is a different take.
+_TTML_LENGTH_SLACK_S = 4
+
+#: Providers whose text depends on `apple_word_by_word`, and so cannot share a
+#: cache entry between the two renderings.
+_TTML_PROVIDERS = frozenset({"binilyrics", "unison"})
+
+
+def _bini_lyrics_url(value: object) -> str:
+    """`value` if it is an https link on Bini's own storage, else "".
+
+    The search answers with the address of the TTML to fetch next. That
+    address comes from a third party's response, so it is only followed
+    when it stays on the host that serves the lyrics.
+    """
+    if not isinstance(value, str):
+        return ""
+    parsed = urllib.parse.urlparse(value)
+    host = parsed.hostname or ""
+    if parsed.scheme != "https" or not (
+        host == "binimum.org" or host.endswith(".binimum.org")
+    ):
+        return ""
+    return value
+
+
+def _best_bini_result(
+    results: object,
+    duration_s: int,
+    isrc: str,
+) -> dict | None:
+    """The best of what Bini's search found for the track.
+
+    A result is taken when its ISRC is the track's own, or its length is
+    within `_TTML_LENGTH_SLACK_S` of it. Among those, word timing beats line
+    timing, then an ISRC match, then the closest length.
+    """
+    best: dict | None = None
+    best_rank: tuple[bool, bool, int] | None = None
+    for item in results if isinstance(results, list) else []:
+        if not isinstance(item, dict) or not _bini_lyrics_url(item.get("lyricsUrl")):
+            continue
+        same_isrc = bool(isrc) and str(item.get("isrc") or "").upper() == isrc.upper()
+        length = item.get("duration")
+        has_length = duration_s > 0 and isinstance(length, (int, float)) and length > 0
+        off = abs(int(length) - duration_s) if has_length else 0
+        if not same_isrc and not (has_length and off <= _TTML_LENGTH_SLACK_S):
+            continue
+        rank = (item.get("timing_type") != "word", not same_isrc, off)
+        if best_rank is None or rank < best_rank:
+            best, best_rank = item, rank
+    return best
+
+
+async def _fetch_bini_async(
+    track_name: str,
+    artist_name: str,
+    album_name: str = "",
+    duration_s: int = 0,
+    isrc: str = "",
+    word_by_word: bool = True,
+    timeout: int = 7,
+) -> str:
+    """BiniLyrics: Apple Music's own TTML for over a million recordings.
+
+    No key. The search answers with metadata and a link; the TTML itself is a
+    second request, to a plain file host.
+    """
+    if not track_name or not artist_name:
+        return ""
+    params = {"track": track_name, "artist": artist_name}
+    if duration_s > 0:
+        params["duration"] = str(duration_s)
+    if album_name:
+        params["album"] = album_name
+    try:
+        from .apple_ttml import ttml_to_lrc
+
+        client = await NetworkManager.get_async_client_safe()
+        r = await client.get(_BINI_API, params=params, timeout=timeout)
+        if r.status_code != 200:
+            return ""
+        payload = r.json()
+        found = _best_bini_result(
+            payload.get("results") if isinstance(payload, dict) else None,
+            duration_s,
+            isrc,
+        )
+        if not found:
+            return ""
+        ttml = await client.get(_bini_lyrics_url(found["lyricsUrl"]), timeout=timeout)
+        if ttml.status_code != 200 or not ttml.text:
+            return ""
+        return ttml_to_lrc(ttml.text, word_by_word=word_by_word)
+    except Exception as exc:
+        logger.debug("[lyrics/binilyrics] async: %s", exc)
+        return ""
+
+
+async def _fetch_unison_async(
+    track_name: str,
+    artist_name: str,
+    album_name: str = "",
+    duration_s: int = 0,
+    isrc: str = "",
+    word_by_word: bool = True,
+    timeout: int = 7,
+) -> str:
+    """Unison: lyrics people write by hand for Better Lyrics.
+
+    A small corpus next to the rest, but what is in it is Apple Music's TTML
+    at its best. Reads need no key; the signed write half of its API (submit,
+    vote, report) is not touched. Only TTML and LRC are taken: its plain text
+    carries nothing the other providers do not.
+    """
+    if not track_name or not artist_name:
+        return ""
+    params = {"song": track_name, "artist": artist_name}
+    if duration_s > 0:
+        params["duration"] = str(duration_s)
+    if album_name:
+        params["album"] = album_name
+    try:
+        from .apple_ttml import ttml_to_lrc
+
+        client = await NetworkManager.get_async_client_safe()
+        r = await client.get(_UNISON_API, params=params, timeout=timeout)
+        if r.status_code != 200:
+            return ""
+        payload = r.json()
+        data = payload.get("data") if isinstance(payload, dict) else None
+        if not isinstance(data, dict) or not isinstance(data.get("lyrics"), str):
+            return ""
+
+        same_isrc = bool(isrc) and str(data.get("isrc") or "").upper() == isrc.upper()
+        length = data.get("duration")
+        length_ok = (
+            duration_s > 0
+            and isinstance(length, (int, float))
+            and length > 0
+            and abs(length - duration_s) <= _TTML_LENGTH_SLACK_S
+        )
+        if not same_isrc and not length_ok:
+            return ""
+
+        if data.get("format") == "ttml":
+            return ttml_to_lrc(data["lyrics"], word_by_word=word_by_word)
+        if data.get("format") == "lrc":
+            return data["lyrics"]
+        return ""
+    except Exception as exc:
+        logger.debug("[lyrics/unison] async: %s", exc)
+        return ""
+
+
+# ---------------------------------------------------------------------------
+# JioSaavn: Hindi and regional-Indian catalogue (Bollywood and beyond)
+# ---------------------------------------------------------------------------
+
+#: JioSaavn's own web player calls this same endpoint. The various
+#: "unofficial JioSaavn API" projects on GitHub are just thin proxies in
+#: front of it, meant to be self-hosted rather than shared publicly, so
+#: going straight to the source avoids depending on someone else's uptime
+#: for data JioSaavn already serves without a key.
+_JIOSAAVN_API = "https://www.jiosaavn.com/api.php"
+_JIOSAAVN_PARAMS = {
+    "_format": "json",
+    "_marker": "0",
+    "api_version": "4",
+    "ctx": "web6dot0",
+}
+_JIOSAAVN_LENGTH_SLACK_S = 4
+
+
+def _best_jiosaavn_result(results: object, duration_s: int) -> dict | None:
+    """The closest-length search hit that JioSaavn actually has lyrics for.
+
+    Most of its catalogue has `has_lyrics: false` — a licensing flag, not a
+    missing-data one — so that is filtered before length is even compared.
+    """
+    best: dict | None = None
+    best_off = 0
+    for item in results if isinstance(results, list) else []:
+        if not isinstance(item, dict) or not item.get("id"):
+            continue
+        more = item.get("more_info")
+        if not isinstance(more, dict) or more.get("has_lyrics") != "true":
+            continue
+        try:
+            length = int(more.get("duration") or 0)
+        except (TypeError, ValueError):
+            length = 0
+        off = abs(length - duration_s) if duration_s > 0 and length > 0 else 0
+        if duration_s > 0 and length > 0 and off > _JIOSAAVN_LENGTH_SLACK_S:
+            continue
+        if best is None or off < best_off:
+            best, best_off = item, off
+    return best
+
+
+async def _fetch_jiosaavn_async(
+    track_name: str,
+    artist_name: str,
+    duration_s: int = 0,
+    timeout: int = 7,
+) -> str:
+    """JioSaavn: plain (unsynced) lyrics, strongest for Hindi and regional
+    Indian languages — a catalogue the other providers barely cover.
+    """
+    if not track_name or not artist_name:
+        return ""
+    try:
+        client = await NetworkManager.get_async_client_safe()
+        search = await client.get(
+            _JIOSAAVN_API,
+            params={
+                **_JIOSAAVN_PARAMS,
+                "__call": "search.getResults",
+                "q": f"{track_name} {artist_name}",
+                "p": "1",
+                "n": "10",
+            },
+            headers={"User-Agent": _UA},
+            timeout=timeout,
+        )
+        if not search.is_success:
+            return ""
+        payload = search.json()
+        found = _best_jiosaavn_result(
+            payload.get("results") if isinstance(payload, dict) else None,
+            duration_s,
+        )
+        if not found:
+            return ""
+        lyrics = await client.get(
+            _JIOSAAVN_API,
+            params={
+                **_JIOSAAVN_PARAMS,
+                "__call": "lyrics.getLyrics",
+                "lyrics_id": str(found["id"]),
+            },
+            headers={"User-Agent": _UA},
+            timeout=timeout,
+        )
+        if not lyrics.is_success:
+            return ""
+        data = lyrics.json()
+        text = data.get("lyrics") if isinstance(data, dict) else None
+        if not isinstance(text, str) or not text.strip():
+            return ""
+        # Some JioSaavn responses carry line breaks as literal `<br>` tags
+        # rather than `\n`; the other providers' output never does, so this
+        # is normalized before it reaches the rest of the pipeline.
+        text = re.sub(r"<br\s*/?>", "\n", text, flags=re.IGNORECASE)
+        return html.unescape(text).strip()
+    except Exception as exc:
+        logger.debug("[lyrics/jiosaavn] async: %s", exc)
+        return ""
+
+
 # ---------------------------------------------------------------------------
 # Async fetch_lyrics — Phase 2 (parallel, as_completed)
 # ---------------------------------------------------------------------------
@@ -993,6 +1264,27 @@ _PROVIDER_MAP = {
         ctx.album_name,
         ctx.duration_s,
     ),
+    "binilyrics": lambda ctx: _fetch_bini_async(
+        ctx.clean_track,
+        ctx.clean_artist,
+        ctx.album_name,
+        ctx.duration_s,
+        ctx.isrc,
+        word_by_word=ctx.apple_word_by_word,
+    ),
+    "unison": lambda ctx: _fetch_unison_async(
+        ctx.clean_track,
+        ctx.clean_artist,
+        ctx.album_name,
+        ctx.duration_s,
+        ctx.isrc,
+        word_by_word=ctx.apple_word_by_word,
+    ),
+    "jiosaavn": lambda ctx: _fetch_jiosaavn_async(
+        ctx.clean_track,
+        ctx.clean_artist,
+        ctx.duration_s,
+    ),
 }
 
 
@@ -1025,12 +1317,15 @@ async def fetch_lyrics_async(
     )
 
     # Apple's word-by-word and line-synced renderings are different text from
-    # the same fetch, so they cannot share a cache entry — but only Apple's
-    # key needs splitting; every other provider ignores the setting.
+    # the same fetch, so they cannot share a cache entry — but only the
+    # providers that read the setting need their key splitting (Apple, and the
+    # TTML catalogues); every other provider ignores it.
     def _provider_track_key(provider_name: str) -> str:
+        mode = "wbw" if apple_word_by_word else "line"
         if provider_name == "apple":
-            mode = "wbw" if apple_word_by_word else "line"
             return f"{track_key}|{mode}|{_APPLE_CACHE_GENERATION}"
+        if provider_name in _TTML_PROVIDERS:
+            return f"{track_key}|{mode}"
         return track_key
 
     def _cached_for(provider_name: str) -> str | None:

spotiflac-4.3.0/SpotiFLAC/core/provider_cooldown.py

@@ -0,0 +1,226 @@
+"""core/provider_cooldown.py — a provider that asked for a break gets one.
+
+tidal-py tries the Community (signed-desktop) gateway first on every track.
+That gateway has enforced pauses — the SpotiFLAC desktop logic it comes from
+blocks downloads for a while — and during one it answers 503 with how long
+the pause lasts: "Please try again in about 51 minute(s)". The extension logs
+that, falls back to public mirrors that time out, and fails; on the next
+track it does all of it again. Roughly 25 seconds per track went to a
+provider that had said, in words, when it would work again.
+
+This reads that answer out of the extension's log and keeps the provider out
+of the rotation until then. The provider is not removed: once the pause is
+over it is tried first again, in the order the user configured. The pause is
+kept in the cache directory, so a restart does not forget it and start the
+25-second detour over.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import threading
+import time
+from pathlib import Path
+from typing import Any
+
+from .atomic_io import write_json_atomic
+from .paths import cache_path
+
+logger = logging.getLogger(__name__)
+
+_CACHE_FILE_NAME = "provider_cooldowns.json"
+
+#: Module (and so logger) prefix of the Python `.sflx` extensions — see
+#: extensions/python_provider._module_name.
+_PLUGIN_PREFIX = "SpotiFLAC.extensions_plugins."
+
+#: Logger prefix of the JS `.sflx` extensions. They have no module of their
+#: own — the bridge relays their log lines from Node — so JSRuntime sends
+#: them out under a child logger named for the extension, which is what
+#: makes one extension's 503 tellable from another's.
+_JS_LOG_PREFIX = "SpotiFLAC.extensions.runtime."
+
+#: How a JS extension provider is named in PROVIDER_REGISTRY — see
+#: extensions/provider.JSExtensionProvider.
+_EXT_NAME_PREFIX = "ext:"
+
+_UNAVAILABLE = re.compile(r"\b503\b")
+_WAIT = re.compile(r"try again in (?:about )?(\d+)\s*(minute|min|hour|h)", re.I)
+
+#: A pause longer than a day is read as a misparse, not as a promise.
+_MAX_PAUSE_S = 24 * 3600
+
+_lock = threading.Lock()
+
+
+def _cache_file() -> Path:
+    return cache_path(_CACHE_FILE_NAME)
+
+
+def _load() -> dict[str, dict]:
+    try:
+        data = json.loads(_cache_file().read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _save(data: dict[str, dict]) -> None:
+    try:
+        write_json_atomic(_cache_file(), data)
+    except OSError:
+        logger.debug("[cooldown] could not write %s", _cache_file(), exc_info=True)
+
+
+def pause_seconds(message: str) -> int:
+    """Seconds a 503 asks to wait before trying again, or 0 if it names none."""
+    if not _UNAVAILABLE.search(message):
+        return 0
+    match = _WAIT.search(message)
+    if not match:
+        return 0
+    amount = int(match.group(1))
+    unit = match.group(2).lower()
+    seconds = amount * 3600 if unit.startswith("h") else amount * 60
+    return min(seconds, _MAX_PAUSE_S)
+
+
+def extension_key(logger_name: str) -> str:
+    """The pause key of the extension that logger belongs to; "" for the host.
+
+    Both kinds of extension are keyed by the name they are installed under:
+
+      "SpotiFLAC.extensions_plugins.tidal_py"  → "tidal-py"   (Python)
+      "SpotiFLAC.extensions.runtime.tidal-web" → "tidal-web"  (JS)
+
+    A Python extension is a module, so its underscores are the ones a module
+    name is obliged to have; a JS extension's logger is named for the
+    extension directly and is left alone.
+    """
+    if logger_name.startswith(_PLUGIN_PREFIX):
+        return logger_name[len(_PLUGIN_PREFIX) :].split(".", 1)[0].replace("_", "-")
+    if logger_name.startswith(_JS_LOG_PREFIX):
+        return logger_name[len(_JS_LOG_PREFIX) :].split(".", 1)[0]
+    return ""
+
+
+def provider_key(provider: Any) -> str:
+    """The pause key of a provider object, or "" if it is not an extension.
+
+    Two ways to the same key, because the two kinds of extension carry their
+    identity in different places. PythonExtensionProvider returns the
+    extension's own provider instance, so the class's module is the
+    extension module whose logger reported the 503. A JS extension is a
+    JSExtensionProvider whatever the extension is, so its module says
+    nothing about which one — its registry name does: "ext:tidal-web" is the
+    extension "tidal-web", the key its log lines already arrive under.
+
+    Keying both from the installed name is what lets pause() and
+    usable_providers() agree: a pause started from a JS extension's log has
+    to name the provider object that gets skipped for it.
+    """
+    key = extension_key(type(provider).__module__)
+    if key:
+        return key
+    name = str(getattr(provider, "name", "") or "")
+    if name.startswith(_EXT_NAME_PREFIX):
+        return name[len(_EXT_NAME_PREFIX) :]
+    return ""
+
+
+def pause(key: str, seconds: float, reason: str = "", now: float | None = None) -> None:
+    """Keeps `key` out of the rotation for `seconds`. A shorter pause never
+    cuts a longer one short."""
+    if not key or seconds <= 0:
+        return
+    now = time.time() if now is None else now
+    until = now + seconds
+    with _lock:
+        data = _load()
+        try:
+            current = float((data.get(key) or {}).get("until", 0))
+        except (TypeError, ValueError):
+            current = 0.0
+        if current >= until:
+            return
+        data[key] = {"until": until, "reason": reason[:300]}
+        _save(data)
+    logger.warning(
+        "[cooldown] %s paused for %d min (until %s): the service asked to try again later",
+        key,
+        max(1, round(seconds / 60)),
+        time.strftime("%H:%M", time.localtime(until)),
+    )
+
+
+def remaining(key: str, now: float | None = None) -> float:
+    """Seconds left on `key`'s pause; 0 when it has none."""
+    if not key:
+        return 0.0
+    now = time.time() if now is None else now
+    try:
+        until = float((_load().get(key) or {}).get("until", 0))
+    except (TypeError, ValueError):
+        return 0.0
+    return max(0.0, until - now)
+
+
+def usable_providers(providers: list) -> list:
+    """`providers` without the ones on a pause, in the same order.
+
+    All of them when every one is paused: a track with nothing left to try
+    would fail without an attempt, and a pause is an estimate, not a ban.
+    """
+    active: list = []
+    paused: list[tuple[Any, float]] = []
+    for provider in providers:
+        left = remaining(provider_key(provider))
+        if left > 0:
+            paused.append((provider, left))
+        else:
+            active.append(provider)
+    if not paused or not active:
+        return list(providers)
+    for provider, left in paused:
+        logger.info(
+            "[cooldown] Skipping %s: paused for another %d min",
+            provider_key(provider),
+            max(1, round(left / 60)),
+        )
+    return active
+
+
+class _PauseWatcher(logging.Handler):
+    """Turns an extension's "503 … try again in about N minute(s)" into a pause."""
+
+    def __init__(self) -> None:
+        super().__init__(level=logging.WARNING)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        key = extension_key(record.name)
+        if not key:
+            return
+        try:
+            message = record.getMessage()
+        except Exception:
+            return
+        seconds = pause_seconds(message)
+        if seconds:
+            pause(key, seconds, message)
+
+
+_watcher = _PauseWatcher()
+
+
+def watch_extension_logs() -> None:
+    """Attaches the watcher to the root logger, again if it was removed.
+
+    Cheap enough to call once per track, which it is: the GUI and --web
+    reconfigure logging with basicConfig(force=True) when the log level
+    changes, and that drops every handler on the root logger.
+    """
+    root = logging.getLogger()
+    if _watcher not in root.handlers:
+        root.addHandler(_watcher)

{spotiflac-4.2.2 → spotiflac-4.3.0}/SpotiFLAC/core/signed_session_desktop.py

@@ -18,9 +18,30 @@ from http.server import BaseHTTPRequestHandler, HTTPServer
 import requests
 
 from SpotiFLAC.core import get_community_url
+from SpotiFLAC.core.signed_session_errors import (
+    parse_session_error,
+    retry_after_header_seconds,
+)
 
 logger = logging.getLogger(__name__)
 
+
+def _refusal_message(what: str, resp) -> str:
+    """ "<what> returned HTTP <code>", with the wait the service asked for.
+
+    The exception raised from it is all a caller ever sees of the response,
+    and a bare "returned HTTP 429" dropped the one thing that says how long
+    the address is limited for. Read from the Retry-After header, else from
+    the gateway's error envelope (see signed_session_errors).
+    """
+    msg = f"{what} returned HTTP {resp.status_code}"
+    wait = retry_after_header_seconds(resp.headers.get("Retry-After"))
+    if not wait:
+        with contextlib.suppress(Exception):
+            wait = parse_session_error(resp.content).retry_after_seconds
+    return f"{msg}, retry after {wait}s" if wait else msg
+
+
 # Costanti
 COMMUNITY_SESSION_SKEW = timedelta(minutes=5)
 # The callback grant is consumed by ``run_community_verification()`` from a
@@ -309,7 +330,7 @@ def run_community_verification(record: CommunitySessionRecord) -> str:
 
         resp = requests.get(bootstrap_url, params=params, timeout=15)
         if resp.status_code != 200:
-            msg = f"verification bootstrap returned HTTP {resp.status_code}"
+            msg = _refusal_message("verification bootstrap", resp)
             raise Exception(msg)
 
         result = resp.json()
@@ -515,7 +536,7 @@ def exchange_community_grant(
     resp = requests.post(url, json=payload, timeout=15)
 
     if resp.status_code != 200:
-        msg = f"session exchange returned HTTP {resp.status_code}"
+        msg = _refusal_message("session exchange", resp)
         raise Exception(msg)
 
     data = resp.json()