python-constricter 0.2.4__py3-none-any.whl → 0.2.7__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.2.4"
+__version__ = "0.2.7"
 __all__ = [
     "COMMENT_TYPED_TARGET",
     "DEFAULT_CHECKS",

constricter/cli/collecting.py

@@ -0,0 +1,47 @@
+# SPDX-License-Identifier: MIT
+"""The garbage collector, as the command runs it: by hand, once per file checked.
+
+A check keeps every file's tree (see `parsed`), and allocates a great deal for each file, little of it
+cyclic. Left to itself, the collector looked through the kept trees again and again as the check
+allocated: a third of the standard library's check (34s, 21s without). So while the command runs,
+it's off: what indexing built is frozen (never looked through again), and after each file, only
+what's been allocated since (the young generations) is collected, which bounds what a cycle can hold.
+"""
+
+import contextlib
+import gc
+from collections.abc import Generator
+from typing import Final
+
+_YOUNG: Final = 1  # the generations collected after each file: 0 and 1, never the frozen or the old
+_FREEZES: Final = hasattr(gc, "freeze")  # PyPy's collector has no freezing
+
+
+@contextlib.contextmanager
+def by_hand() -> Generator[None]:
+    """Turn automatic collection off for the command's run, and back as it was after.
+
+    Yields:
+      Nothing: the run.
+
+    """
+    was: bool = gc.isenabled()
+    gc.disable()
+    try:
+        yield
+    finally:
+        if _FREEZES:
+            gc.unfreeze()
+        if was:
+            gc.enable()
+
+
+def indexed() -> None:
+    """Freeze what indexing built (the kept trees, the index): it lives until the check takes it."""
+    if _FREEZES:
+        gc.freeze()
+
+
+def sweep() -> None:
+    """Collect what the file just checked left behind (see the module docstring)."""
+    _ = gc.collect(_YOUNG)

constricter/cli/command.py

@@ -4,25 +4,27 @@
 import codecs
 import contextlib
 import difflib
+import importlib
 import io
-import itertools
 import json
 import sys
 import tokenize
-from collections.abc import Callable, Mapping, Sequence
-from concurrent.futures import ProcessPoolExecutor
-from dataclasses import dataclass, field, replace
+from collections.abc import Callable, Sequence
+from dataclasses import replace
 from functools import partial
 from pathlib import Path
-from typing import Final, NamedTuple, TextIO, TypeAlias, cast
+from typing import TYPE_CHECKING, Final, NamedTuple, TextIO, TypeAlias, cast
 
 from constricter import notebook
-from constricter.cli import baseline, hints
+from constricter.cli import baseline, collecting, schedule
 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.fix import fixes, project
-from constricter.fix.known import Hints, Outside
+from constricter.fix.known import Hints, Outside, Returns
 from constricter.noqa import lines, unsuppressed
 from constricter.offences import (
     DEFAULT_CHECKS,
@@ -30,7 +32,10 @@ from constricter.offences import (
     Edit,
     Offence,
 )
-from constricter.rules.checker import Coverage, annotation_coverage, check_source
+from constricter.rules.checker import Checked, Coverage, annotation_coverage, checked_source
+
+if TYPE_CHECKING:  # slow to import, and only needed for `--infer-with`
+    from constricter.cli import hints
 
 EXIT_CLEAN: Final = 0
 EXIT_FOUND: Final = 1
@@ -74,30 +79,29 @@ def _source(raw: str, name: Path) -> tuple[str, list[notebook.Line]]:
     return notebook.parse(raw, str(name)) if name.suffix == notebook.SUFFIX else (raw, [])
 
 
-def check_text(
+def checked_text(
     raw: str,
     name: Path,
     checks: Checks = DEFAULT_CHECKS,
     *,
     outside: Outside | None = None,
-) -> list[Offence]:
-    """Return the offences in `raw`, the text of `name`, that no `# noqa` suppresses.
+) -> Checked:
+    """Check `raw`, the text of `name`: the offences no `# noqa` suppresses.
 
     A notebook's code cells are checked as one module, and each offence placed in its cell.
     Raises `ValueError` for a `.ipynb` that isn't a notebook.
 
     Returns:
-      The unsuppressed offences, a notebook's placed in their cells.
+      The unsuppressed offences, a notebook's placed in their cells, and what its functions return
+      (see `Checked`).
 
     """
     source: str
     where: list[notebook.Line]
     source, where = _source(raw, name)
-    offences: list[Offence] = unsuppressed(
-        check_source(source, str(name), checks, outside=outside),
-        lines(source),
-    )
-    return [_placed(o, where) for o in offences] if where else offences
+    checked: Checked = checked_source(source, str(name), checks, outside=outside)
+    offences: list[Offence] = unsuppressed(checked.offences, lines(source))
+    return checked._replace(offences=[_placed(o, where) for o in offences] if where else offences)
 
 
 def _placed(offence: Offence, where: list[notebook.Line]) -> Offence:
@@ -110,7 +114,8 @@ def _placed(offence: Offence, where: list[notebook.Line]) -> Offence:
     """
     line: notebook.Line = where[offence.line - 1]
     placed: Offence = replace(offence, line=line.line, cell=line.cell)
-    if offence.edit is not None and offence.edit.imports:  # a notebook's cells have no import block
+    # A notebook's cells have no import block.
+    if offence.edit is not None and (offence.edit.imports or offence.edit.guarded):
         return replace(placed, edit=None)
     if offence.edit is not None and offence.edit.edit is Edit.DECLARE:
         statement: int = where[offence.edit.span[0] - 1].line
@@ -175,34 +180,6 @@ def fix_file(path: Path, offences: Sequence[Offence]) -> int:
     return count
 
 
-@dataclass(frozen=True)
-class _CheckRun:
-    """What checking one file found (and fixed, or would fix), in check/fix/diff mode."""
-
-    results: list[Result] = field(default_factory=list[Result])
-    baselined: int = 0
-    fixed: int = 0  # --fix: how many offences it fixed
-    text: str = ""  # --diff: the diff; --fix on standard input: the fixed source
-    error: str = ""
-
-
-@dataclass(frozen=True)
-class _BaselineRun:
-    """One file's offences, unfiltered, for --write-baseline."""
-
-    found: list[Offence] = field(default_factory=list[Offence])
-    error: str = ""
-
-
-@dataclass(frozen=True)
-class _CoverageRun:
-    """One file's annotation coverage, for --coverage."""
-
-    coverage: Coverage | None = None
-    error: str = ""
-
-
-_FileRun: TypeAlias = _CheckRun | _BaselineRun | _CoverageRun
 HINT_ROUNDS: Final = 4  # with `--fix --infer-with`: how many times each file is fixed, at most
 
 
@@ -222,15 +199,15 @@ def _shown_lines(raw: str, name: Path) -> dict[tuple[int | None, int], str]:
     }
 
 
-def _checked(path: Path, name: Path, checks: Checks, outside: Outside) -> tuple[str, list[Offence]]:
+def _checked(path: Path, name: Path, checks: Checks, outside: Outside) -> tuple[str, Checked]:
     """Read `path` and check it as `name`; raises what reading or parsing it does.
 
     Returns:
-      Its text, and its offences.
+      Its text, and what checking it found.
 
     """
     raw: str = _read(path)
-    return raw, check_text(raw, name, checks, outside=outside)
+    return raw, checked_text(raw, name, checks, outside=outside)
 
 
 def _read_checked(
@@ -238,20 +215,20 @@ def _read_checked(
     name: Path,
     checks: Checks,
     outside: Outside,
-) -> tuple[str, list[Offence], str]:
+) -> tuple[str, Checked, str]:
     """Read and check `path`, turning a read or parse error into a message instead of raising.
 
     Returns:
-      Its text and offences (empty on error), and the error message (empty on success).
+      Its text and what checking it found (nothing on error), and the error message (empty on success).
 
     """
     raw: str
-    offences: list[Offence]
+    checked: Checked
     try:
-        raw, offences = _checked(path, name, checks, outside)
+        raw, checked = _checked(path, name, checks, outside)
     except (OSError, ValueError, SyntaxError) as error:  # UnicodeDecodeError is a ValueError
-        return "", [], f"{name}: error: {error}"
-    return raw, offences, ""
+        return "", Checked([], Returns()), f"{name}: error: {error}"
+    return raw, checked, ""
 
 
 def _results(raw: str, name: Path, offences: Sequence[Offence], options: Options) -> list[Result]:
@@ -273,7 +250,7 @@ def _results(raw: str, name: Path, offences: Sequence[Offence], options: Options
     ]
 
 
-def _check_path(path: Path, outside: Outside, options: Options) -> _CheckRun:
+def _check_path(path: Path, outside: Outside, options: Options) -> CheckRun:
     """Check (and fix, or diff) one file, given what's known of it from outside it.
 
     Returns:
@@ -282,11 +259,24 @@ def _check_path(path: Path, outside: Outside, options: Options) -> _CheckRun:
     """
     name: Path = options.input.name(path)
     raw: str
-    offences: list[Offence]
+    checked: Checked
     error: str
-    raw, offences, error = _read_checked(path, name, options.checks, outside)
+    raw, checked, error = _read_checked(path, name, options.checks, outside)
     if error:
-        return _CheckRun(error=error)
+        return CheckRun(error=error)
+    return replace(_handled(path, (raw, name), checked.offences, options), returned=checked.returned)
+
+
+def _handled(path: Path, text: tuple[str, Path], offences: list[Offence], options: Options) -> CheckRun:
+    """Report, fix or diff the offences found in `path` (`text`: its text, and its name).
+
+    Returns:
+      What was found, and fixed.
+
+    """
+    raw: str
+    name: Path
+    raw, name = text
     baselined: int
     offences, baselined = options.filter.unbaselined(name, offences)
     results: list[Result] = _results(raw, name, offences, options)
@@ -295,22 +285,22 @@ def _check_path(path: Path, outside: Outside, options: Options) -> _CheckRun:
         r.offence for r in results if r.offence.edit is not None and (unsafe or not r.offence.unsafe)
     ]
     if options.mode is Mode.DIFF:
-        return _CheckRun(text=_diff(raw, name, fixing))
+        return CheckRun(text=_diff(raw, name, fixing))
     if options.mode is not Mode.FIX:
-        return _CheckRun(results, baselined)
+        return CheckRun(results, baselined)
     left: list[Result] = [r for r in results if r.offence not in fixing]
     if path == STDIN:  # the fixed source goes to stdout
-        return _CheckRun(left, baselined, len(fixing), _fixed(raw, name, fixing).text)
+        return CheckRun(left, baselined, len(fixing), _fixed(raw, name, fixing).text)
     try:
-        return _CheckRun(left, baselined, fix_file(path, fixing))
+        return CheckRun(left, baselined, fix_file(path, fixing))
     except UnicodeEncodeError as failure:  # the file is left as it was, its offences unfixed
         # Its canonical name: PyPy reports `latin1` where CPython says `latin-1`.
         encoding: str = codecs.lookup(failure.encoding).name
         message: str = f"an annotation can't be written in its encoding, {encoding}; left as it was"
-        return _CheckRun(results, baselined, error=f"{name}: error: {message}")
+        return CheckRun(results, baselined, error=f"{name}: error: {message}")
 
 
-def _baseline_path(path: Path, outside: Outside, options: Options) -> _BaselineRun:
+def _baseline_path(path: Path, outside: Outside, options: Options) -> BaselineRun:
     """Check one file, unfiltered, for --write-baseline.
 
     Returns:
@@ -318,13 +308,13 @@ def _baseline_path(path: Path, outside: Outside, options: Options) -> _BaselineR
 
     """
     name: Path = options.input.name(path)
-    offences: list[Offence]
+    checked: Checked
     error: str
-    _, offences, error = _read_checked(path, name, options.checks, outside)
-    return _BaselineRun(error=error) if error else _BaselineRun(found=offences)
+    _, checked, error = _read_checked(path, name, options.checks, outside)
+    return BaselineRun(error=error) if error else BaselineRun(checked.offences, returned=checked.returned)
 
 
-def _cover_path(path: Path, _outside: Outside, options: Options) -> _CoverageRun:
+def _cover_path(path: Path, _outside: Outside, options: Options) -> CoverageRun:
     """Count one file's typed first bindings.
 
     Returns:
@@ -333,12 +323,12 @@ def _cover_path(path: Path, _outside: Outside, options: Options) -> _CoverageRun
     """
     name: Path = options.input.name(path)
     try:
-        return _CoverageRun(annotation_coverage(_source(_read(path), name)[0], options.checks))
+        return CoverageRun(annotation_coverage(_source(_read(path), name)[0], options.checks))
     except (OSError, ValueError, SyntaxError) as error:
-        return _CoverageRun(error=f"{name}: error: {error}")
+        return CoverageRun(error=f"{name}: error: {error}")
 
 
-def _check_all(options: Options) -> tuple[list[Path], list[_FileRun]]:
+def _check_all(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
@@ -352,7 +342,7 @@ def _check_all(options: Options) -> tuple[list[Path], list[_FileRun]]:
 
     """
     paths: list[Path] = list(python_files(options.input.paths, options.input.exclude))
-    check: Callable[[Path, Outside], _FileRun]
+    check: Callable[[Path, Outside], FileRun]
     if options.mode is Mode.COVERAGE:
         check = partial(_cover_path, options=options)
     elif options.mode is Mode.WRITE_BASELINE:
@@ -363,20 +353,26 @@ def _check_all(options: Options) -> tuple[list[Path], list[_FileRun]]:
     if not options.infer_with or options.mode in {Mode.COVERAGE, Mode.WRITE_BASELINE}:
         return names, _checked_all(paths, check, options)[0]
     session: hints.Session
-    with hints.Session(options.infer_with, Path.cwd(), options.jobs, options.infer_memory) as session:
-        runs: list[_FileRun]
+    # 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)(
+        options.infer_with,
+        Path.cwd(),
+        options.jobs,
+        options.infer_memory,
+    ) as session:
+        runs: list[FileRun]
         modules: project.Index
         runs, modules = _checked_all(paths, 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
+            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(
+            redone: list[FileRun] = _checked_all(
                 [paths[i] for i in again],
                 check,
                 options,
@@ -384,20 +380,20 @@ def _check_all(options: Options) -> tuple[list[Path], list[_FileRun]]:
                 modules,
             )[0]
             index: int
-            run: _FileRun
+            run: FileRun
             for index, run in zip(again, redone, strict=True):
-                runs[index] = _merged(cast("_CheckRun", runs[index]), cast("_CheckRun", run))
-            again = [index for index, run in zip(again, redone, strict=True) if cast("_CheckRun", run).fixed]
+                runs[index] = _merged(runs[index], run)
+            again = [index for index, run in zip(again, redone, strict=True) if cast("CheckRun", run).fixed]
     return names, runs
 
 
 def _checked_all(
     paths: Sequence[Path],
-    check: Callable[[Path, Outside], _FileRun],
+    check: Callable[[Path, Outside], FileRun],
     options: Options,
-    session: hints.Session | None = None,
+    session: "hints.Session | None" = None,
     modules: project.Index | None = None,
-) -> tuple[list[_FileRun], project.Index]:
+) -> tuple[list[FileRun], project.Index]:
     """Check `paths` (`--jobs` at a time), with the `session`'s hints, and `modules` (else indexed).
 
     Returns:
@@ -406,30 +402,35 @@ def _checked_all(
     """
     hinted: dict[Path, tuple[Hints, ...]] = {} if session is None else session.hints(_texts(paths))
     coverage: bool = options.mode is Mode.COVERAGE  # needs nothing from the other files
-    if options.jobs == 1 or len(paths) <= 1:
-        if modules is None:
+    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)
-        return list(
-            itertools.starmap(check, zip(paths, _outside(modules, paths, hinted), strict=True)),
-        ), modules
-    pool: ProcessPoolExecutor
-    with ProcessPoolExecutor(max_workers=options.jobs) as pool:
-        if modules is None:
-            # The index, as the checks, read one file per task.
-            modules = (
-                project.Index({}, []) if coverage else project.index(paths, partial(pool.map, chunksize=16))
-            )
-        return list(pool.map(check, paths, _outside(modules, paths, hinted))), modules
-
-
-def _merged(before: _CheckRun, after: _CheckRun) -> _CheckRun:
-    """Join a file's two `--fix` rounds: what's left is the later round's, what's fixed is both's.
+            collecting.indexed()
+        return schedule.checked(
+            paths,
+            check,
+            pool,
+            (modules, hinted),
+            _merged if options.mode is Mode.FIX else None,
+        )
+
+
+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.
 
     """
-    return replace(after, fixed=before.fixed + after.fixed)
+    first: CheckRun = cast("CheckRun", before)
+    later: CheckRun = cast("CheckRun", after)
+    return replace(later, fixed=first.fixed + later.fixed)
 
 
 def _texts(paths: Sequence[Path]) -> dict[Path, str]:
@@ -451,33 +452,14 @@ def _texts(paths: Sequence[Path]) -> dict[Path, str]:
     return texts
 
 
-def _outside(
-    modules: project.Index,
-    paths: Sequence[Path],
-    hinted: Mapping[Path, tuple[Hints, ...]],
-) -> list[Outside]:
-    """Find what's known of each file from outside it: what it imports from the others, and its hints.
-
-    Returns:
-      Each file's, in order.
-
-    """
-    found: list[Outside] = []
-    path: Path
-    for path in paths:
-        imported: project.Imported = project.imported(modules, path)
-        found.append(Outside(imported.calls, imported.classes, hinted.get(path, ())))
-    return found
-
-
-def _report(options: Options, runs: Sequence[_FileRun], files: int) -> int:
+def _report(options: Options, runs: Sequence[FileRun], files: int) -> int:
     """Print the results (`runs` is check/fix/diff mode's: every other mode has its own printing).
 
     Returns:
       The exit status.
 
     """
-    checked: Sequence[_CheckRun] = cast("Sequence[_CheckRun]", runs)
+    checked: Sequence[CheckRun] = cast("Sequence[CheckRun]", runs)
     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}
@@ -502,14 +484,14 @@ def _report(options: Options, runs: Sequence[_FileRun], files: int) -> int:
     return EXIT_FOUND if errors else EXIT_CLEAN
 
 
-def _coverage(options: Options, paths: Sequence[Path], runs: Sequence[_FileRun]) -> int:
+def _coverage(options: Options, paths: Sequence[Path], runs: Sequence[FileRun]) -> int:
     """Print each file's and the total annotation coverage (`runs` is --coverage mode's).
 
     Returns:
       The exit status.
 
     """
-    covered: Sequence[_CoverageRun] = cast("Sequence[_CoverageRun]", runs)
+    covered: Sequence[CoverageRun] = cast("Sequence[CoverageRun]", runs)
     counted: list[tuple[Path, Coverage]] = [
         (path, run.coverage) for path, run in zip(paths, covered, strict=True) if run.coverage is not None
     ]
@@ -545,18 +527,19 @@ def _run(options: Options) -> int:
 
     """
     names: list[Path]
-    runs: list[_FileRun]
-    try:
-        names, runs = _check_all(options)
-    except hints.HintError as error:
-        _ = sys.stderr.write(f"constricter: error: {error}\n")
-        return EXIT_ERROR
+    runs: list[FileRun]
+    with collecting.by_hand():
+        try:
+            names, runs = _check_all(options)
+        except HintError as error:
+            _ = sys.stderr.write(f"constricter: error: {error}\n")
+            return EXIT_ERROR
     _ = sys.stderr.write("".join(f"{run.error}\n" for run in runs if run.error))
     failed: bool = any(run.error for run in runs)
     status: int
     if options.mode is Mode.WRITE_BASELINE and options.filter.baseline_file is not None:
         file: Path = options.filter.baseline_file
-        baselined: Sequence[_BaselineRun] = cast("Sequence[_BaselineRun]", runs)
+        baselined: Sequence[BaselineRun] = cast("Sequence[BaselineRun]", runs)
         found: dict[str, list[Offence]] = {
             baseline.key(n, file): run.found for n, run in zip(names, baselined, strict=True)
         }
@@ -565,12 +548,12 @@ def _run(options: Options) -> int:
     elif options.mode is Mode.COVERAGE:
         status = _coverage(options, names, runs)
     elif options.mode is Mode.DIFF:
-        checked: Sequence[_CheckRun] = cast("Sequence[_CheckRun]", runs)
+        checked: Sequence[CheckRun] = cast("Sequence[CheckRun]", runs)
         diffs: str = "".join(run.text for run in checked)
         _ = sys.stdout.write(diffs)
         status = EXIT_FOUND if diffs else EXIT_CLEAN
     elif options.mode is Mode.FIX and options.input.paths == [STDIN] and runs and not failed:
-        fixed: _CheckRun = cast("_CheckRun", runs[0])
+        fixed: CheckRun = cast("CheckRun", runs[0])
         _ = sys.stdout.write(fixed.text)  # standard input, fixed, is the whole output
         status = EXIT_FOUND if any(r.offence.is_error(r.level) for r in fixed.results) else EXIT_CLEAN
     else:

constricter/cli/config.py

@@ -7,7 +7,7 @@ from functools import partial
 from pathlib import Path
 from typing import TYPE_CHECKING, Final, TypeAlias
 
-from constricter.cli.hints import SERVERS
+from constricter.cli.protocol import SERVERS
 from constricter.jsonc import is_int
 from constricter.offences import FIX_KINDS, LEVELS, MESSAGES
 
@@ -165,24 +165,17 @@ def _levels(value: _Toml) -> dict[str, str] | None:
     return None if None in levels.values() else {glob: str(level) for glob, level in levels.items()}
 
 
-def _ignores(value: _Toml) -> dict[str, list[str]] | None:
-    if not isinstance(value, dict):
-        return None
-    ignores: dict[str, list[str] | None] = {glob: _codes(codes) for glob, codes in value.items()}
-    return None if None in ignores.values() else {glob: list(codes or []) for glob, codes in ignores.items()}
-
-
-def _narrower(value: _Toml) -> dict[str, list[str]] | None:
-    """Read a type hierarchy: each type, and the list of types it's narrower than.
+def _lists(value: _Toml, read: Callable[[_Toml], list[str] | None]) -> dict[str, list[str]] | None:
+    """Read a table of lists, each as `read` reads one: `per-file-ignores`' codes, `narrower`'s types.
 
     Returns:
-      It, or `None` if `value` isn't a table of string lists.
+      It, or `None` if `value` isn't a table, or `read` can't read one of its values.
 
     """
     if not isinstance(value, dict):
         return None
-    wider: dict[str, list[str] | None] = {name: _strings(types) for name, types in value.items()}
-    return None if None in wider.values() else {name: list(types or []) for name, types in wider.items()}
+    lists: dict[str, list[str] | None] = {key: read(item) for key, item in value.items()}
+    return None if None in lists.values() else {key: list(item or []) for key, item in lists.items()}
 
 
 def _baseline(value: _Toml, root: Path) -> str | None:
@@ -211,8 +204,8 @@ _READERS: dict[str, Callable[[_Toml], Default | None]] = {
     "type-comments": _flag,
     "all-scopes": _flag,
     "per-path-levels": _levels,
-    "per-file-ignores": _ignores,
-    "narrower": _narrower,
+    "per-file-ignores": partial(_lists, read=_codes),
+    "narrower": partial(_lists, read=_strings),  # a type hierarchy: each type, and those it's narrower than
     "infer-with": _checkers,
     "infer-memory": _gigabytes,
 }