python-constricter 0.3.3__py3-none-any.whl → 0.3.6__py3-none-any.whl

constricter/__init__.py

@@ -25,7 +25,7 @@ from constricter.offences import (
 )
 from constricter.rules.checker import Coverage, annotation_coverage, check_source, check_tree
 
-__version__ = "0.3.3"
+__version__ = "0.3.6"
 __all__ = [
     "COMMENT_TYPED_TARGET",
     "DEFAULT_CHECKS",

constricter/__main__.py

@@ -1,9 +1,26 @@
 # SPDX-License-Identifier: MIT
-"""`python -m constricter`."""
+"""`python -m constricter`, and the `constricter` script."""
 
+import contextlib
+import os
 import sys
 
 from constricter.cli.command import main
 
+
+def run() -> None:
+    """Run the command, and leave with its status at once.
+
+    Not by the interpreter's own exit, which frees every parsed file and the index an object at a
+    time: a fifth of a check of a thousand files. What the command wrote is flushed first; nothing
+    else waits on the exit (its workers have ended, its output file is closed).
+    """
+    status: int = main()
+    with contextlib.suppress(OSError, ValueError):  # a reader that left, a stream closed already
+        _ = sys.stdout.flush()
+        _ = sys.stderr.flush()
+    os._exit(status)
+
+
 if __name__ == "__main__":  # not when `--jobs` workers import it
-    sys.exit(main())
+    run()

constricter/cli/command.py

@@ -21,16 +21,17 @@ from constricter.cli.options import Mode, Options, Output
 from constricter.cli.paths import STDIN, python_files
 from constricter.cli.protocol import HintError
 from constricter.cli.report import Format, Result, fix_reasons, render, statistics
-from constricter.cli.runs import BaselineRun, CheckRun, CoverageRun, FileRun
-from constricter.cli.workers import Workers
+from constricter.cli.runs import Added, BaselineRun, CheckRun, CoverageRun, FileRun, merged
+from constricter.cli.workers import Workers, kept, started
 from constricter.fix.core import fixes
 from constricter.fix.core.known import Callee, Hints, Outside, Returns
-from constricter.fix.index import callers, decorated, installed, plain, project
+from constricter.fix.index import callers, decorated, installed, loose, plain, project
 from constricter.noqa import lines, unsuppressed
 from constricter.offences import (
     DEFAULT_CHECKS,
     Checks,
     Edit,
+    Fix,
     Offence,
 )
 from constricter.rules import parsed
@@ -127,6 +128,7 @@ def _placed(offence: Offence, where: list[notebook.Line]) -> Offence:
 
 
 # One changed part of a fixed file (the file, or a notebook's cell): its label, old and new lines.
+_Hinted: TypeAlias = dict[Path, tuple[Hints, ...]]  # each file's hints, a checker's each
 _Change: TypeAlias = tuple[str, list[str], list[str]]
 # One JSON value a coverage report holds, and one file's row of them.
 _Scalar: TypeAlias = str | int | float
@@ -183,7 +185,10 @@ def fix_file(path: Path, offences: Sequence[Offence]) -> int:
     return count
 
 
-HINT_ROUNDS: Final = 4  # with `--fix --infer-with`: how many times each file is fixed, at most
+HINT_ROUNDS: Final = 4  # with `--fix`: how many times a file is fixed, at most (see `_settled`)
+# The fix kinds a scope's check comes to late, once the scope is read: what was bound to such a
+# name's value before had no type yet, and has one once the fix is written.
+_LATE_KINDS: Final = frozenset({"optional", "filled"})
 
 
 def _shown_lines(raw: str, name: Path) -> dict[tuple[int | None, int], str]:
@@ -287,9 +292,8 @@ def _handled(path: Path, text: tuple[str, Path], offences: list[Offence], option
     baselined: int
     offences, baselined = options.filter.unbaselined(name, offences)
     results: list[Result] = _results(raw, name, offences, options)
-    unsafe: bool = options.unsafe_fixes
     fixing: list[Offence] = [
-        r.offence for r in results if r.offence.edit is not None and (unsafe or not r.offence.unsafe)
+        r.offence for r in results if r.offence.edit is not None and options.guesses.applies(r.offence)
     ]
     if options.mode is Mode.DIFF:
         return CheckRun(text=_diff(raw, name, fixing))
@@ -308,7 +312,29 @@ def _handled(path: Path, text: tuple[str, Path], offences: list[Offence], option
         return CheckRun(results, baselined, error=f"{name}: error: {message}")
     if fixed:
         _ = parsed.take(raw)  # the tree of the text it had: no check will ask for it again
-    return CheckRun(left, baselined, fixed)
+    return CheckRun(
+        left,
+        baselined,
+        fixed,
+        made=[r._replace(replacements=(), fixed=True) for r in results if r.offence in fixing],
+        rounds=(_added(raw, name, fixing),),
+    )
+
+
+def _added(raw: str, name: Path, fixing: Sequence[Offence]) -> Added:
+    """Find the lines fixing `fixing` adds to `raw`, the text of `name` (see `fixes.inserted`).
+
+    Returns:
+      Each one's cell (`None` outside a notebook) and the line it goes before; a notebook's cells
+      get declarations alone.
+
+    """
+    if name.suffix != notebook.SUFFIX:
+        return tuple((None, line) for line in fixes.inserted(lines(raw), fixing))
+    declared: list[tuple[int, int]] = [
+        (o.cell or 0, o.edit.span[0]) for o in fixing if o.edit is not None and o.edit.edit is Edit.DECLARE
+    ]
+    return tuple(sorted(declared))
 
 
 def _baseline_path(path: Path, outside: Outside, options: Options) -> BaselineRun:
@@ -340,13 +366,23 @@ def _cover_path(path: Path, _outside: Outside, options: Options) -> CoverageRun:
 
 
 def _check_all(options: Options) -> tuple[list[Path], list[FileRun]]:
+    """Check every file (see `_check_rounds`), its rounds by one set of worker processes.
+
+    Returns:
+      The names, and what each file found.
+
+    """
+    with kept():
+        return _check_rounds(options)
+
+
+def _check_rounds(options: Options) -> tuple[list[Path], list[FileRun]]:
     """Check every file (`--jobs` at a time), in order.
 
     With `--infer-with`, the type checker's server runs throughout: it's asked for every file's
     hints first, and with `--fix`, each file a round changed is asked again and checked again, as its
-    new annotations change what the checker infers, until a round changes nothing (at most
-    `HINT_ROUNDS`). A baseline records offences, and coverage counts annotations: hints change
-    neither, only what `--fix` offers.
+    new annotations change what the checker infers (see `_settled`). A baseline records offences,
+    and coverage counts annotations: hints change neither, only what `--fix` offers.
 
     Returns:
       The names, and what each file found.
@@ -364,7 +400,7 @@ def _check_all(options: Options) -> tuple[list[Path], list[FileRun]]:
     if options.mode in {Mode.COVERAGE, Mode.WRITE_BASELINE}:
         return names, _checked_all(paths, check, options)[0]
     if not options.infer_with:
-        return names, _called_again(paths, _checked_all(paths, check, options), check, options)[0]
+        return names, _settled(paths, check, options, None)
     session: hints.Session
     # Imported only for `--infer-with`: it's slow to import, for every run's start.
     with cast("type[hints.Session]", importlib.import_module("constricter.cli.hints").Session)(
@@ -373,36 +409,7 @@ def _check_all(options: Options) -> tuple[list[Path], list[FileRun]]:
         options.jobs,
         options.infer_memory,
     ) as session:
-        runs: list[FileRun]
-        modules: project.Index
-        runs, modules = _called_again(
-            paths,
-            _checked_all(paths, check, options, session),
-            check,
-            options,
-            session,
-        )
-        # The files the last round changed: only their hints can have changed.
-        again: list[int] = [
-            index
-            for index, run in enumerate(runs)
-            if options.mode is Mode.FIX and isinstance(run, CheckRun) and run.fixed and paths[index] != STDIN
-        ]
-        for _ in range(HINT_ROUNDS - 1):
-            if not again:
-                break
-            redone: list[FileRun] = _checked_all(
-                [paths[i] for i in again],
-                check,
-                options,
-                session,
-                modules,
-            )[0]
-            index: int
-            run: FileRun
-            for index, run in zip(again, redone, strict=True):
-                runs[index] = _merged(runs[index], run)
-            again = [index for index, run in zip(again, redone, strict=True) if cast("CheckRun", run).fixed]
+        runs: list[FileRun] = _settled(paths, check, options, session)
         checker: str
         path: Path
         for checker, path in session.abandoned:
@@ -411,6 +418,65 @@ def _check_all(options: Options) -> tuple[list[Path], list[FileRun]]:
     return names, runs
 
 
+def _settled(
+    paths: Sequence[Path],
+    check: Callable[[Path, Outside], FileRun],
+    options: Options,
+    session: "hints.Session | None",
+) -> list[FileRun]:
+    """Check every file, then again each one `--fix` changed in a way a second check would see.
+
+    Until a round changes nothing, `HINT_ROUNDS` at most: a second pass is then left nothing.
+
+    Returns:
+      What each file found, a file's rounds joined.
+
+    """
+    runs: list[FileRun]
+    modules: project.Index
+    runs, modules = _called_again(
+        paths,
+        _checked_all(paths, check, options, session),
+        check,
+        options,
+        session,
+    )
+    again: list[int] = [
+        index
+        for index, run in enumerate(runs)
+        if options.mode is Mode.FIX and paths[index] != STDIN and _unsettled(run, session)
+    ]
+    for _ in range(HINT_ROUNDS - 1):
+        if not again:
+            break
+        redone: list[FileRun] = _checked_all([paths[i] for i in again], check, options, session, modules)[0]
+        index: int
+        run: FileRun
+        for index, run in zip(again, redone, strict=True):
+            runs[index] = merged(runs[index], run)
+        again = [index for index, run in zip(again, redone, strict=True) if _unsettled(run, session)]
+    return runs
+
+
+def _unsettled(run: FileRun, session: "hints.Session | None") -> bool:
+    """Check whether a round of `--fix` changed a file in a way that changes what's inferred there.
+
+    Returns:
+      Whether it fixed anything, with a type checker's hints: its new annotations change them.
+      Without, whether it made a fix the scope's check comes to late (`_LATE_KINDS`): what's bound
+      to such a name's value was read before its type was known.
+
+    """
+    checked: CheckRun = cast("CheckRun", run)
+    return bool(checked.fixed) and (
+        session is not None
+        or any(
+            isinstance(made.offence.edit, Fix) and made.offence.edit.kinds & _LATE_KINDS
+            for made in checked.made
+        )
+    )
+
+
 def _called_again(
     paths: Sequence[Path],
     first: tuple[list[FileRun], project.Index],
@@ -447,7 +513,7 @@ def _called_again(
     calling = [
         at
         for at in calling
-        if project.returned(modules, paths[at], {}) != project.returned(before, paths[at], {})
+        if loose.returned(modules, paths[at], {}) != loose.returned(before, paths[at], {})
     ]
     return runs, _checked_more(paths, runs, calling, (check, options, session), modules)
 
@@ -473,7 +539,7 @@ def _checked_more(
     at: int
     run: FileRun
     for at, run in zip(which, redone, strict=True):
-        runs[at] = _merged(runs[at], run) if how[1].mode is Mode.FIX else run
+        runs[at] = merged(runs[at], run) if how[1].mode is Mode.FIX else run
     return modules
 
 
@@ -509,44 +575,29 @@ def _checked_all(
       What each file found, and the index of every file's module.
 
     """
-    hinted: dict[Path, tuple[Hints, ...]] = {} if session is None else session.hints(_texts(paths))
+    # Before a worker starts: one forked while the servers' threads run could wait on a lock one holds.
+    hinted: _Hinted = {} if session is None else session.hints(_texts(paths))
     if options.input.trace is not None:
         hinted = traced.merged(hinted, traced.load(options.input.trace), paths)
     coverage: bool = options.mode is Mode.COVERAGE  # needs nothing from the other files
-    stack: contextlib.ExitStack
-    with contextlib.ExitStack() as stack:
-        pool: Workers | None = None
-        if options.jobs != 1 and len(paths) > 1:
-            pool = stack.enter_context(Workers(paths, options.jobs))
-        if modules is None and pool:
-            modules = project.Index({}, []) if coverage else pool.index()
-        elif modules is None:
-            modules = project.Index({}, []) if coverage else project.index(paths)
-            collecting.indexed()
-        if not coverage:
-            modules = plain.settled(
-                decorated.passed(installed.with_installed(modules, installed.search_path())),
-                options.checks.plain_bases,
-            )
-        return schedule.checked(
-            paths,
-            check,
-            pool,
-            (modules, hinted),
-            _merged if options.mode is Mode.FIX else None,
+    pool: Workers | None = started(paths, options.jobs) if options.jobs != 1 and len(paths) > 1 else None
+    if modules is None and pool:
+        modules = project.Index({}, []) if coverage else pool.index()
+    elif modules is None:
+        modules = project.Index({}, []) if coverage else project.index(paths)
+        collecting.indexed()
+    if not coverage:
+        modules = plain.settled(
+            decorated.passed(installed.with_installed(modules, installed.search_path())),
+            options.checks.plain_bases,
         )
-
-
-def _merged(before: FileRun, after: FileRun) -> FileRun:
-    """Join a file's two `--fix` rounds' `CheckRun`s: what's left is the later's, what's fixed is both's.
-
-    Returns:
-      The joined run.
-
-    """
-    first: CheckRun = cast("CheckRun", before)
-    later: CheckRun = cast("CheckRun", after)
-    return replace(later, fixed=first.fixed + later.fixed)
+    return schedule.checked(
+        paths,
+        check,
+        pool,
+        (modules, hinted),
+        merged if options.mode is Mode.FIX else None,
+    )
 
 
 def _texts(paths: Sequence[Path]) -> dict[Path, str]:
@@ -579,10 +630,16 @@ def _report(options: Options, runs: Sequence[FileRun], files: int) -> int:
     results: list[Result] = [result for run in checked for result in run.results]
     output: Output = options.output
     text: bool = output.fmt in {Format.TEXT, Format.FULL}
+    # With `--show-fixes`, the fixes `--fix` made too: after the rest, as text or JSON.
+    shown: list[Result] = [*results, *(made for run in checked if output.show_fixes for made in run.made)]
     line: str
-    for line in statistics(results) if text and output.statistics else render(output.fmt, results):
+    for line in (
+        statistics(results)
+        if text and output.statistics
+        else render(output.fmt, shown if output.fmt is Format.JSON else results)
+    ):
         _ = sys.stdout.write(f"{line}\n")
-    for line in fix_reasons(results) if text and output.show_fixes else ():
+    for line in fix_reasons(shown) if text and output.show_fixes else ():
         _ = sys.stdout.write(f"{line}\n")
     errors: int = sum(r.offence.is_error(r.level) for r in results)
     if text and not output.quiet:
@@ -593,7 +650,10 @@ def _report(options: Options, runs: Sequence[FileRun], files: int) -> int:
             parts.append(f"fixed {sum(run.fixed for run in checked)}")
             guesses: int
             if guesses := sum(r.offence.unsafe for r in results):
-                parts.append(f"{guesses} more with --unsafe-fixes")
+                likely: int = sum(r.offence.likely for r in results)
+                parts.append(
+                    f"{guesses} more with --unsafe-fixes" + f" ({likely} with --likely)" * bool(likely),
+                )
         if options.filter.baseline_file is not None:
             parts.append(f"{sum(run.baselined for run in checked)} baselined")
         _ = sys.stdout.write("; ".join(parts) + ".\n")
@@ -611,30 +671,53 @@ def _coverage(options: Options, paths: Sequence[Path], runs: Sequence[FileRun])
     counted: list[tuple[Path, Coverage]] = [
         (path, run.coverage) for path, run in zip(paths, covered, strict=True) if run.coverage is not None
     ]
-    total: Coverage = Coverage(sum(c.typed for _, c in counted), sum(c.total for _, c in counted))
+    total: Coverage = Coverage(
+        sum(c.typed for _, c in counted),
+        sum(c.total for _, c in counted),
+        sum(c.widened for _, c in counted),
+    )
     if options.output.fmt is Format.JSON:
         report: dict[str, _Scalar | list[_Row]] = {
-            "typed": total.typed,
-            "total": total.total,
-            "percent": round(total.percent, 1),
-            "files": [
-                {"path": str(path), "typed": c.typed, "total": c.total, "percent": round(c.percent, 1)}
-                for path, c in counted
-            ],
+            **_counts(total),
+            "files": [{"path": str(path), **_counts(c)} for path, c in counted],
         }
         _ = sys.stdout.write(json.dumps(report, indent=2) + "\n")
     else:
         path: Path
         c: Coverage
         for path, c in counted:
-            _ = sys.stdout.write(f"{path}: {c.typed}/{c.total} typed ({c.percent:.1f}%)\n")
-        _ = sys.stdout.write(
-            f"Total: {total.typed}/{total.total} typed ({total.percent:.1f}%) in {len(counted)} file(s).\n",
-        )
+            _ = sys.stdout.write(f"{path}: {_typed(c)}\n")
+        _ = sys.stdout.write(f"Total: {_typed(total)} in {len(counted)} file(s).\n")
     threshold: float | None = options.output.fail_under
     return EXIT_FOUND if threshold is not None and total.percent < threshold else EXIT_CLEAN
 
 
+def _counts(found: Coverage) -> _Row:
+    """Name a coverage's counts, for `--format=json`.
+
+    Returns:
+      Them, by name.
+
+    """
+    return {
+        "typed": found.typed,
+        "total": found.total,
+        "widened": found.widened,
+        "percent": round(found.percent, 1),
+    }
+
+
+def _typed(found: Coverage) -> str:
+    """Write a coverage as text: `3/4 typed (75.0%)`, then what a widening annotated, if anything.
+
+    Returns:
+      It.
+
+    """
+    wider: str = f", {found.widened} widened" if found.widened else ""
+    return f"{found.typed}/{found.total} typed ({found.percent:.1f}%){wider}"
+
+
 def _run(options: Options) -> int:
     """Check, fix, diff, count or baseline, printing what that finds.
 

constricter/cli/config.py

@@ -10,7 +10,7 @@ from typing import TYPE_CHECKING, Final, TypeAlias, cast
 
 from constricter.cli.protocol import SERVERS
 from constricter.jsonc import is_int
-from constricter.offences import FIX_KINDS, LEVELS, MESSAGES
+from constricter.offences import FIX_KINDS, LEVELS, MESSAGES, WIDEN_KINDS
 
 if TYPE_CHECKING:
     from datetime import date, datetime, time
@@ -32,6 +32,7 @@ def unknown_codes(codes: Sequence[str]) -> list[str]:
 
 DEFAULT_BASELINE: Final = "constricter-baseline.json"
 _MIN_PYTHON: Final = "min_python"
+_ALL_KINDS: Final = "all"  # `fix-widen`'s: every wider type
 _VERSION: Final = re.compile(r"\d+\.\d+")  # `min-python`'s: `3.11`
 # A lower bound among `requires-python`'s specifiers: `>=3.11`, `~=3.11`, `==3.11.*`, `>3.10`.
 _LOWER_BOUND: Final = re.compile(r"(?:>=|~=|==|>)\s*(\d+)(?:\.(\d+))?")
@@ -160,6 +161,31 @@ def unknown_fix_kinds(kinds: Sequence[str]) -> list[str]:
     return [kind for kind in kinds if kind not in FIX_KINDS]
 
 
+def unknown_widen_kinds(kinds: Sequence[str]) -> list[str]:
+    """Check `kinds` against `WIDEN_KINDS`' ids, and `all`.
+
+    Returns:
+      Those that aren't one.
+
+    """
+    return [kind for kind in kinds if kind not in WIDEN_KINDS | {_ALL_KINDS}]
+
+
+def widen_kinds(kinds: Sequence[str]) -> list[str]:
+    """Read `fix-widen`'s kinds, `all` as every one.
+
+    Returns:
+      Them.
+
+    """
+    return sorted(WIDEN_KINDS) if _ALL_KINDS in kinds else list(kinds)
+
+
+def _widen_kinds(value: _Toml) -> list[str] | None:
+    kinds: list[str] | None = [value] if isinstance(value, str) else _strings(value)
+    return None if kinds is None or unknown_widen_kinds(kinds) else widen_kinds(kinds)
+
+
 def _fix_kinds(value: _Toml) -> list[str] | None:
     kinds: list[str] | None = _strings(value)
     return None if kinds is None or unknown_fix_kinds(kinds) else kinds
@@ -246,6 +272,7 @@ _READERS: dict[str, Callable[[_Toml], Default | None]] = {
     "fix-select": _fix_kinds,
     "fix-ignore": _fix_kinds,
     "unsafe-fix-select": _fix_kinds,
+    "fix-widen": _widen_kinds,
     "fix-plain-bases": _strings,
     "type-comments": _flag,
     "all-scopes": _flag,

constricter/cli/hints.py

@@ -33,7 +33,7 @@ from functools import partial
 from pathlib import Path
 from typing import IO, Final, NamedTuple, Self, TypeAlias, cast
 
-from constricter.cli import edits, guard, protocol
+from constricter.cli import edits, guard, protocol, remembered
 from constricter.cli.protocol import SERVERS, HintError, HungError, Server
 from constricter.fix.core.known import Hints, Offered
 
@@ -47,8 +47,6 @@ _Task: TypeAlias = Callable[[], _Found]  # one server's work: the hints of each
 
 _BATCH: Final = 8  # files a free server takes at a time: few, so none is left with the slow ones
 MEMORY: Final = 8 << 30  # the most a checker's servers use together, by default (`--infer-memory`)
-_SERVER_MEMORY: Final = 600 << 20  # a server's memory, before the files (basedpyright's, measured)
-_MEMORY_PER_BYTE: Final = 130  # and for each byte of them: 1.2 GB for SQLAlchemy's 8 MB, 3.4 for pandas' 21
 _MEMINFO: Final = Path("/proc/meminfo")
 _FILES_PER_SERVER: Final = 32  # fewer files than this each don't pay for another server's start
 # Seconds without a word from a server before it's taken for hung. Not an answer's wait: pandas'
@@ -228,11 +226,10 @@ class Checker:
     """One checker's servers, and which of them has each file.
 
     It has as many as its files need (one per `_FILES_PER_SERVER`), up to the command's `--jobs`, the
-    checker's own most (`Server.most`: one for a checker that works in parallel itself), and as many
-    as fit in its memory: `--infer-memory` (never more than is available), or by default `MEMORY`
-    (never more than half what's available). Each server loads the whole program it checks, which
-    takes (as measured) about `_SERVER_MEMORY` plus `_MEMORY_PER_BYTE` for each byte of the files.
-    One server it always has, whatever the memory.
+    checker's own most (`Server.most`), and as many as fit in its memory: `--infer-memory` (never
+    more than is available), or by default `MEMORY` (never more than half what's available). Each
+    server loads the whole program it checks, or its share of it, by its checker's own measure (see
+    `Server.fitting`). One server it always has, whatever the memory.
 
     The files are handed out a few at a time (`_BATCH`), the biggest first, to whichever server is
     free: one file's analysis can take far longer than another's, and none waits on a busy one. A
@@ -244,7 +241,8 @@ class Checker:
         self.name: str = name
         self.root: Path = root
         self.command: list[str] = command(name)
-        self.most: int = max(1, min(servers, SERVERS[name].most))
+        self.server: Server = SERVERS[name]
+        self.most: int = max(1, min(servers, self.server.most))
         self.memory: int = budget(memory, available_memory())
         self.servers: list[Connection] = []
         self.assigned: dict[Path, int] = {}  # each file's server, by its place in `servers`
@@ -258,13 +256,14 @@ class Checker:
 
         """
         size: int = sum(len(text) for text in files.values())
-        fit: int = max(1, self.memory // (_SERVER_MEMORY + _MEMORY_PER_BYTE * size))
+        fit: int = max(1, self.server.fitting(self.memory, size))
         return max(len(self.servers), min(self.most, -(-len(files) // _FILES_PER_SERVER), fit))
 
     def tasks(self, files: Mapping[Path, str]) -> list[_Task]:
         """Make each server's work on `files`: its own files first, then new ones as it's free for them.
 
-        A file abandoned (see `_alone`) isn't asked about again.
+        A file abandoned (see `_alone`), in this run or an earlier one (see `remembered`), isn't
+        asked about again.
 
         Returns:
           A task per server, giving the hints of every file it was sent.
@@ -274,8 +273,14 @@ class Checker:
         path: Path
         for path in files.keys() & self.assigned.keys() - self.abandoned:
             own.setdefault(self.assigned[path], {})[path] = files[path]
+        # One it hung on in an earlier run, unchanged since: left without hints from the start.
+        self.abandoned.update(
+            path
+            for path in files.keys() - self.assigned.keys() - self.abandoned
+            if remembered.hung(self.name, self.command, files[path])
+        )
         fresh: list[Path] = sorted(
-            files.keys() - self.assigned.keys(),
+            files.keys() - self.assigned.keys() - self.abandoned,
             key=lambda new: (-len(files[new]), new),
         )
         batches: queue.SimpleQueue[dict[Path, str]] = queue.SimpleQueue()
@@ -352,6 +357,7 @@ class Checker:
                 found.update(server.answers(server.ask({path: text})))
             except HungError as hung:
                 self.abandoned.add(path)
+                remembered.remember(self.name, self.command, text)
                 if len(self.abandoned) > _MOST_ABANDONED:
                     error: str = f"{self.name} hung on {len(self.abandoned)} file(s), each asked about alone"
                     raise HintError(error) from hung
@@ -810,6 +816,6 @@ class Connection:
                     cast("IO[bytes]", self.process.stdin),
                     f"Content-Length: {len(body)}\r\n\r\n".encode() + body,
                 )
-            except OSError as error:
+            except (OSError, ValueError) as error:  # it has gone, or its input was closed to stop it
                 failure: str = f"{self.name} exited: {error}"
                 raise HintError(failure) from error