docs: make the stopped-run translate tests deterministic

The test added in the previous commit assumed the rejected page is seen
before its sibling lands; with four pages and two in flight the loop may
legitimately start a third page first, which then waited alone at the
test's barrier. Split it into two order-independent tests: a sibling that
lands beside a rejected page is written (exactly two pages in the run),
and no further page starts once the rejection is seen (both in flight
rejected). The worker now hands a ConfigError back as a value like a
PageError, so that page's usage is counted and the loop needs no except.

Author: maxisbey

scripts/docs/translations.py

@@ -974,20 +974,20 @@ def command_translate(repo: Repo, args: argparse.Namespace, translator: Translat
     if translator is None and any(job.open for _, job in work):
         translator = anthropic_translator()
 
-    def produce(inputs: Inputs, job: Job) -> tuple[str | PageError, Usage]:
-        """One page's body (or why it failed) and the tokens it cost; runs on a pool thread."""
+    def produce(inputs: Inputs, job: Job) -> tuple[str | PageError | ConfigError, Usage]:
+        """The page body, or why it failed or must stop the run, with the tokens it cost; runs on a pool thread."""
         spent = Usage()
         try:
             body = translate_page(repo, inputs, job, translator, model, spent) if translator else reassemble(repo, job)
-        except PageError as exc:
+        except (PageError, ConfigError) as exc:
             return exc, spent
         return body, spent
 
     active = sorted({inputs.language.code for inputs, _ in work}, key=[lang.code for lang in languages].index)
     print(f"translating {len(work)} pages ({', '.join(active)}), {args.jobs} at a time, with {model}", flush=True)
     usage, failed = Usage(), False
     queue = deque(work)
-    running: dict[Future[tuple[str | PageError, Usage]], tuple[Language, Job]] = {}
+    running: dict[Future[tuple[str | PageError | ConfigError, Usage]], tuple[Language, Job]] = {}
     stopped: ConfigError | None = None  # rejected credentials: start nothing more, keep what still lands
     pool = ThreadPoolExecutor(max_workers=args.jobs)
     try:
@@ -1000,12 +1000,11 @@ def produce(inputs: Inputs, job: Job) -> tuple[str | PageError, Usage]:
                 running[pool.submit(produce, inputs, job)] = (inputs.language, job)
             for future in wait(running, return_when=FIRST_COMPLETED).done:
                 language, job = running.pop(future)
-                try:
-                    result, spent = future.result()
-                except ConfigError as exc:
-                    stopped = stopped or exc
-                    continue
+                result, spent = future.result()
                 usage.add(spent)
+                if isinstance(result, ConfigError):
+                    stopped = stopped or result
+                    continue
                 page = job.state.page
                 if isinstance(result, PageError):
                     failed = True

tests/docs/test_translations.py

@@ -960,37 +960,57 @@ def complete(self, *, model: str, system: str, messages: Sequence[t.Message], ma
     assert run(capsys, root, "status") == (0, "ja (日本語): 0 missing, 0 outdated, 4 current, 0 removable\n", "")
 
 
-def test_rejected_credentials_with_pages_in_flight_start_no_further_page_but_a_finished_one_is_kept(
+class RejectedTogether:
+    """Lets two requests in together, then rejects the credentials of those whose page title is in `rejected`."""
+
+    def __init__(self, rejected: Sequence[str]) -> None:
+        self.rejected, self.calls = rejected, 0
+        self.both, self.lock = threading.Barrier(2, timeout=5), threading.Lock()
+
+    def complete(self, *, model: str, system: str, messages: Sequence[t.Message], max_tokens: int) -> t.Completion:
+        with self.lock:
+            self.calls += 1
+        self.both.wait()
+        if any(title in messages[0].content for title in self.rejected):
+            raise t.ConfigError("the API rejected the credentials: invalid bearer token")
+        return t.Completion(TOOLS_JA, t.Usage(10, 4, 0, 9))
+
+
+def test_rejected_credentials_keep_a_page_that_lands_from_the_same_flight(
     tmp_path: Path, capsys: pytest.CaptureFixture[str]
 ) -> None:
-    """Tool-defined: with `--jobs 2`, when the API rejects the credentials for one page while another is in
-    flight (here both are waiting before either is answered), the other page still lands and is written,
-    the two remaining pages are never requested, usage is reported, and the run stops with exit 2."""
+    """Tool-defined: with two pages in flight together, the credentials being rejected for one does not throw
+    away the other: whichever lands first, the good page is written and usage reported before exit 2."""
     root = make_repo(tmp_path)
+    fake = RejectedTogether(["# Home"])
 
-    class RejectsHome:
-        def __init__(self) -> None:
-            self.both, self.lock, self.calls = threading.Barrier(2, timeout=5), threading.Lock(), 0
+    code, out, err = translate(capsys, root, "--lang", "ja", "--pages", "index.md", "tools.md", jobs=2, translator=fake)
+
+    assert (code, fake.calls, err) == (2, 2, "translations: the API rejected the credentials: invalid bearer token\n")
+    assert out == snapshot("""\
+translating 2 pages (ja), 2 at a time, with test-model
+ja: translated tools.md (3 of 3 sections)
+usage: 10 input / 4 output / 0 cache-write / 9 cache-read tokens
+""")
+    assert sorted(path.name for path in (root / "i18n" / "ja" / "pages").glob("*.md")) == ["tools.md"]
 
-        def complete(self, *, model: str, system: str, messages: Sequence[t.Message], max_tokens: int) -> t.Completion:
-            with self.lock:
-                self.calls += 1
-            self.both.wait()
-            if "# Home" in messages[0].content:
-                raise t.ConfigError("the API rejected the credentials: invalid bearer token")
-            return t.Completion(TOOLS_JA, t.Usage(10, 4, 0, 9))
 
-    fake = RejectsHome()
+def test_rejected_credentials_with_pages_in_flight_start_no_further_page(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """Tool-defined: with `--jobs 2` over four pages, once the credentials are rejected (here for both pages in
+    flight) the two remaining pages are never requested and nothing is written."""
+    root = make_repo(tmp_path)
+    fake = RejectedTogether(["# Home", "# Tools"])
 
     code, out, err = translate(capsys, root, "--lang", "ja", jobs=2, translator=fake)
 
     assert (code, fake.calls, err) == (2, 2, "translations: the API rejected the credentials: invalid bearer token\n")
     assert out == snapshot("""\
 translating 4 pages (ja), 2 at a time, with test-model
-ja: translated tools.md (3 of 3 sections)
-usage: 10 input / 4 output / 0 cache-write / 9 cache-read tokens
+usage: 0 input / 0 output / 0 cache-write / 0 cache-read tokens
 """)
-    assert sorted(path.name for path in (root / "i18n" / "ja" / "pages").glob("*.md")) == ["tools.md"]
+    assert not (root / "i18n" / "ja" / "pages").exists()
 
 
 def test_translate_without_lang_works_through_every_language_with_that_languages_own_prompt(