digest: translate variants once per active non-en language

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

app/jobs/email_digest_job.py

@@ -30,6 +30,7 @@ from app.models import EmailSend, User
 from app.routers.email import sign_unsubscribe_token
 from app.services.access import paid_status
 from app.services.email_service import render_digest_email, send_email
+from app.services.i18n import ACTIVE_LANGUAGES
 from app.services.openrouter import (
     PROMPT_VERSION,
     build_daily_digest_prompt,
@@ -37,6 +38,7 @@ from app.services.openrouter import (
     call_llm,
     llm_configured,
 )
+from app.services.translation import translate
 
 
 def _now() -> datetime:
@@ -116,6 +118,62 @@ def _kind_for_today(today: datetime) -> str:
     return "weekly" if today.weekday() == 6 else "daily"
 
 
+async def _translate_variants_for_active_langs(
+    client,
+    english_variants: dict[str, str],
+    target_langs: list[str],
+) -> dict[tuple[str, str], str]:
+    """Build a {(tone, lang): content_md} table.
+
+    Starts with the English variants as the canonical cells. For each
+    (tone, target_lang) pair where target_lang != 'en', calls translate()
+    in parallel; on failure the cell falls back to the English variant
+    of the same tone so the digest still goes out, just untranslated.
+    """
+    table: dict[tuple[str, str], str] = {
+        (tone, "en"): content for tone, content in english_variants.items()
+    }
+    pairs = [
+        (tone, lang)
+        for tone in english_variants
+        for lang in target_langs
+        if lang != "en"
+    ]
+    if not pairs:
+        return table
+
+    results = await asyncio.gather(*[
+        translate(client, english_variants[tone], lang) for tone, lang in pairs
+    ], return_exceptions=True)
+    for (tone, lang), result in zip(pairs, results):
+        if isinstance(result, Exception):
+            log.warning("digest.translate.failed",
+                        tone=tone, lang=lang, error=str(result)[:200])
+            table[(tone, lang)] = english_variants[tone]
+            continue
+        translated_md, _llm_log = result
+        table[(tone, lang)] = translated_md
+    return table
+
+
+def _pick_variant(
+    table: dict[tuple[str, str], str], tone: str, lang: str,
+) -> str:
+    """Return the digest content for a recipient.
+
+    Lookup order: exact (tone, lang) → (tone, 'en') → ('INTERMEDIATE',
+    'en') → first table value. The last falls are defensive; the table
+    always contains at least one English entry when the job is sending.
+    """
+    if (tone, lang) in table:
+        return table[(tone, lang)]
+    if (tone, "en") in table:
+        return table[(tone, "en")]
+    if ("INTERMEDIATE", "en") in table:
+        return table[("INTERMEDIATE", "en")]
+    return next(iter(table.values()))
+
+
 async def _send_one(user: User, kind: str, content_html: str, date_str: str,
                     session) -> None:
     settings_url = f"{branding.SITE_URL}/settings"
@@ -200,17 +258,21 @@ async def run() -> None:
             jr.error = "all variants failed"
             return
 
+        # Build the per-language translation table once per job run.
+        active_non_en = sorted({l for l in ACTIVE_LANGUAGES if l != "en"})
+        async with httpx.AsyncClient(follow_redirects=True) as client:
+            variant_table = await _translate_variants_for_active_langs(
+                client, variants, active_non_en,
+            )
+
         written = 0
         for u in fresh:
             tone = (u.digest_tone or "INTERMEDIATE").upper()
-            # Fall back to INTERMEDIATE first (the more common tone) and then
-            # to whatever variant succeeded, so an asymmetric LLM failure
-            # doesn't silently skip the user.
-            content = (variants.get(tone)
-                       or variants.get("INTERMEDIATE")
-                       or next(iter(variants.values()), None))
-            if content is None:
-                continue
+            content = _pick_variant(
+                variant_table,
+                tone=tone,
+                lang=(u.lang or "en"),
+            )
             await _send_one(u, kind, content, date_str, session)
             await asyncio.sleep(0.1)
             written += 1