EchoScript : 20260630 0857 - _marian_model_exists() , _safe_marian_exists() , HF_TOKEN/HUGGINGFACE_HUB_TOKEN

app.py

@@ -325,7 +325,7 @@ with gr.Blocks(title="EchoScript") as demo:
 **Upload Audio → Select Audio Window → Detect Language & Generate Transcript
 → Preview & Choose Languages → Generate Translations → Copy / Download**
 
-<sub>build: 2026-06-28 22:17 UTC &middot; fixed en-jap Helsinki-NLP naming exception</sub>
+<sub>build: 2026-06-30 08:57 UTC &middot; fixed: rate-limited Hub checks were being cached as "language unavailable"</sub>
         """
     )
 

services/translation.py

@@ -231,31 +231,68 @@ def _marian_model_exists(source_language: str, target_language: str) -> bool:
     deliberately kept separate from _try_load_marian_engine so the UI can
     cheaply ask "what's actually available for this source language"
     without paying the cost of downloading every candidate model.
-    Cached forever per pair: this is public catalog data, not something
-    that changes mid-session, and reusing it means the second person (or
-    the second transcript) asking about the same source language is
-    instant.
+
+    Only a confirmed 404 (the repo genuinely doesn't exist) is cached as
+    False. Anything else -- rate limiting, a timeout, a transient network
+    error -- raises instead of being swallowed into a False. This matters
+    because @lru_cache only caches a function's return value, never an
+    exception it raised: if this returned False for a rate-limited
+    request, that wrong "doesn't exist" answer would be locked in for the
+    rest of the session (this is what was hiding Persian as a translation
+    target from English, even though Helsinki-NLP/opus-mt-en-fa genuinely
+    exists -- a burst of ~30+ unauthenticated existence checks during one
+    transcript's language-detection step is enough to get rate-limited).
+    Callers must catch the transient case themselves (see
+    _safe_marian_exists) and decide what "I don't know yet" should mean
+    for that call site, rather than this function silently deciding it.
     """
     from huggingface_hub import HfApi
     from huggingface_hub.utils import HfHubHTTPError
 
     try:
-        HfApi().model_info(_marian_repo_id(source_language, target_language))
+        HfApi(token=_hf_token()).model_info(_marian_repo_id(source_language, target_language))
         return True
-    except HfHubHTTPError:
-        return False
-    except Exception:  # pragma: no cover - network hiccup, treat as unavailable
-        return False
+    except HfHubHTTPError as exc:
+        status_code = getattr(getattr(exc, "response", None), "status_code", None)
+        if status_code == 404:
+            return False
+        raise  # 429 / 5xx / etc. -- not proof the model doesn't exist
+
+
+def _safe_marian_exists(source_language: str, target_language: str) -> bool:
+    """`_marian_model_exists`, but transient failures fail open.
+
+    A genuine 404 still means "not available". Anything else (rate
+    limiting, a network blip) is treated as "available" for this one
+    call rather than "unavailable" -- erring toward occasionally offering
+    a language whose Hub check happened to fail transiently (the actual
+    translate() call will surface a clear per-language error if it truly
+    isn't there) rather than silently and permanently hiding one that's
+    really there, which is the bug this replaces.
+    """
+    try:
+        return _marian_model_exists(source_language, target_language)
+    except Exception:
+        return True
+
+
+def _hf_token() -> Optional[str]:
+    """An HF token, if one is configured -- raises the unauthenticated
+    rate limit that triggers the failure above in the first place.
+    Optional; everything here still works without one, just with a lower
+    request budget before transient failures become likely.
+    """
+    return os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_HUB_TOKEN")
 
 
 def _marian_path_exists(source_language: str, target_language: str) -> bool:
     """Direct pair, or a source->en->target pivot, whichever is real."""
     if source_language == target_language:
         return False
-    if _marian_model_exists(source_language, target_language):
+    if _safe_marian_exists(source_language, target_language):
         return True
     if source_language != "en" and target_language != "en":
-        return _marian_model_exists(source_language, "en") and _marian_model_exists("en", target_language)
+        return _safe_marian_exists(source_language, "en") and _safe_marian_exists("en", target_language)
     return False