python-constricter 0.3.2__tar.gz → 0.3.3__tar.gz

{python_constricter-0.3.2 → python_constricter-0.3.3}/.gitignore

@@ -42,6 +42,7 @@ stdlib_tables/partial.json
 /.claude/skills
 /.claude/workflows
 /.claude/.cc-writes
+/.vscode
 
 # Backups merge tools leave next to a conflicted file.
 *.orig

{python_constricter-0.3.2 → python_constricter-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-constricter
-Version: 0.3.2
+Version: 0.3.3
 Import-Name: constricter
 Summary: Lint rules: every local variable is typed where it's first bound. A flake8 plugin, a pylint plugin and a standalone CLI.
 Author: Ivy Duggan
@@ -187,6 +187,7 @@ Options:
 | type hierarchy   | -                                                                                                                                                                            | `narrower` (a table)                            | `--constricter-narrower`        | `constricter-narrower`            |
 | fix              | `--fix` (`--unsafe-fixes` for guesses), `--diff` to preview                                                                                                                  | -                                               | -                               | -                                 |
 | infer with       | `--infer-with CHECKERS` (`basedpyright`, `ty`, `pyrefly`, several: inferred types, as guesses)                                                                               | `infer-with`                                    | -                               | -                                 |
+| infer from       | `--infer-from FILE` (the types `python -m constricter.trace -m pytest` recorded from a run, as guesses)                                                                      | `infer-from`                                    | -                               | -                                 |
 | show fixes       | `--show-fixes` (each fix and how it was decided, text)                                                                                                                       | -                                               | -                               | -                                 |
 | fix levels       | `--fix-select`, `--fix-ignore`, `--unsafe-fix-select` (mechanisms: [docs/FIXES.md](https://github.com/ivylikethevine/python-constricter/blob/main/docs/FIXES.md#fix-levels)) | `fix-select`, `fix-ignore`, `unsafe-fix-select` | -                               | -                                 |
 | fix plain bases  | `--fix-plain-bases BASES` (frameworks' classes whose subclasses' bodies `--fix` annotates; django's are built in)                                                            | `fix-plain-bases`                               | -                               | -                                 |
@@ -246,7 +247,8 @@ method call of a local whose type is known, and values computed from those; a lo
 unpacking's names get a declaration on the line before. `--unsafe-fixes` adds guesses, and
 `--show-fixes` lists each fix and how its value decided it. `--infer-with basedpyright` (or `ty`, or
 `pyrefly`, or several: `basedpyright,ty`; each installed alongside) asks those type checkers for
-what `--fix` can't type itself, as guesses. The full list is in
+what `--fix` can't type itself, as guesses; `--infer-from FILE` takes the types a run bound each
+name to, recorded by `python -m constricter.trace -m pytest`, the same way. The full list is in
 [docs/FIXES.md](https://github.com/ivylikethevine/python-constricter/blob/main/docs/FIXES.md).
 
 ### Installing and running
@@ -272,7 +274,7 @@ pre-commit, after ruff's hooks (or `constricter-fix`, which runs `--fix` first):
 
 ```yaml
 - repo: https://github.com/ivylikethevine/python-constricter
-  rev: v0.3.2
+  rev: v0.3.3
   hooks:
     - id: constricter
 ```

{python_constricter-0.3.2 → python_constricter-0.3.3}/README.md

@@ -160,6 +160,7 @@ Options:
 | type hierarchy   | -                                                                                                                                                                            | `narrower` (a table)                            | `--constricter-narrower`        | `constricter-narrower`            |
 | fix              | `--fix` (`--unsafe-fixes` for guesses), `--diff` to preview                                                                                                                  | -                                               | -                               | -                                 |
 | infer with       | `--infer-with CHECKERS` (`basedpyright`, `ty`, `pyrefly`, several: inferred types, as guesses)                                                                               | `infer-with`                                    | -                               | -                                 |
+| infer from       | `--infer-from FILE` (the types `python -m constricter.trace -m pytest` recorded from a run, as guesses)                                                                      | `infer-from`                                    | -                               | -                                 |
 | show fixes       | `--show-fixes` (each fix and how it was decided, text)                                                                                                                       | -                                               | -                               | -                                 |
 | fix levels       | `--fix-select`, `--fix-ignore`, `--unsafe-fix-select` (mechanisms: [docs/FIXES.md](https://github.com/ivylikethevine/python-constricter/blob/main/docs/FIXES.md#fix-levels)) | `fix-select`, `fix-ignore`, `unsafe-fix-select` | -                               | -                                 |
 | fix plain bases  | `--fix-plain-bases BASES` (frameworks' classes whose subclasses' bodies `--fix` annotates; django's are built in)                                                            | `fix-plain-bases`                               | -                               | -                                 |
@@ -219,7 +220,8 @@ method call of a local whose type is known, and values computed from those; a lo
 unpacking's names get a declaration on the line before. `--unsafe-fixes` adds guesses, and
 `--show-fixes` lists each fix and how its value decided it. `--infer-with basedpyright` (or `ty`, or
 `pyrefly`, or several: `basedpyright,ty`; each installed alongside) asks those type checkers for
-what `--fix` can't type itself, as guesses. The full list is in
+what `--fix` can't type itself, as guesses; `--infer-from FILE` takes the types a run bound each
+name to, recorded by `python -m constricter.trace -m pytest`, the same way. The full list is in
 [docs/FIXES.md](https://github.com/ivylikethevine/python-constricter/blob/main/docs/FIXES.md).
 
 ### Installing and running
@@ -245,7 +247,7 @@ pre-commit, after ruff's hooks (or `constricter-fix`, which runs `--fix` first):
 
 ```yaml
 - repo: https://github.com/ivylikethevine/python-constricter
-  rev: v0.3.2
+  rev: v0.3.3
   hooks:
     - id: constricter
 ```

{python_constricter-0.3.2 → python_constricter-0.3.3}/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.2"
+__version__ = "0.3.3"
 __all__ = [
     "COMMENT_TYPED_TARGET",
     "DEFAULT_CHECKS",

{python_constricter-0.3.2 → python_constricter-0.3.3}/constricter/cli/command.py

@@ -16,7 +16,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Final, NamedTuple, TextIO, TypeAlias, cast
 
 from constricter import notebook
-from constricter.cli import baseline, collecting, schedule
+from constricter.cli import baseline, collecting, schedule, traced
 from constricter.cli.options import Mode, Options, Output
 from constricter.cli.paths import STDIN, python_files
 from constricter.cli.protocol import HintError
@@ -33,6 +33,7 @@ from constricter.offences import (
     Edit,
     Offence,
 )
+from constricter.rules import parsed
 from constricter.rules.checker import Checked, Coverage, annotation_coverage, checked_source
 
 if TYPE_CHECKING:  # slow to import, and only needed for `--infer-with`
@@ -297,13 +298,17 @@ def _handled(path: Path, text: tuple[str, Path], offences: list[Offence], option
     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)
+    fixed: int
     try:
-        return CheckRun(left, baselined, fix_file(path, fixing))
+        fixed = 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}")
+    if fixed:
+        _ = parsed.take(raw)  # the tree of the text it had: no check will ask for it again
+    return CheckRun(left, baselined, fixed)
 
 
 def _baseline_path(path: Path, outside: Outside, options: Options) -> BaselineRun:
@@ -505,6 +510,8 @@ def _checked_all(
 
     """
     hinted: dict[Path, tuple[Hints, ...]] = {} 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:

{python_constricter-0.3.2 → python_constricter-0.3.3}/constricter/cli/config.py

@@ -223,7 +223,7 @@ def _lists(value: _Toml, read: Callable[[_Toml], list[str] | None]) -> dict[str,
 
 
 def _baseline(value: _Toml, root: Path) -> str | None:
-    """Read a baseline path, relative to `root` (the pyproject.toml that names it).
+    """Read a baseline's or a trace's path, relative to `root` (the pyproject.toml that names it).
 
     Returns:
       The resolved path, or `None` if `value` isn't a non-empty string.
@@ -276,6 +276,7 @@ def config_defaults(start: Path) -> dict[str, Default]:
     readers: dict[str, Callable[[_Toml], Default | None]] = {
         **_READERS,
         "baseline": partial(_baseline, root=path.parent),
+        "infer-from": partial(_baseline, root=path.parent),
     }
     defaults: dict[str, Default] = {}
     key: str

{python_constricter-0.3.2 → python_constricter-0.3.3}/constricter/cli/options.py

@@ -11,7 +11,7 @@ from pathlib import Path
 from typing import Final, cast
 
 from constricter import __version__
-from constricter.cli import baseline
+from constricter.cli import baseline, traced
 from constricter.cli.config import (
     DEFAULT_BASELINE,
     config_defaults,
@@ -353,6 +353,12 @@ def _parser() -> argparse.ArgumentParser:
         metavar="GB",
         help="with --infer-with: the most memory each checker's servers use together (default: 8)",
     )
+    _ = parser.add_argument(
+        "--infer-from",
+        type=Path,
+        metavar="FILE",
+        help="type what --fix can't with the types `python -m constricter.trace` recorded, as guesses",
+    )
     _ = parser.add_argument(
         "--diff",
         action="store_true",
@@ -440,6 +446,7 @@ class Input:
     paths: list[Path]
     exclude: list[str]
     stdin_name: Path = STDIN
+    trace: Path | None = None  # the trace whose types `--fix` guesses with (`--infer-from`)
 
     def name(self, path: Path) -> Path:
         """Name `path` for reports.
@@ -566,7 +573,12 @@ class Options:
             parser.error("`-` (standard input) must be the only path")
         mode: Mode = _mode(parser, args)
         return cls(
-            input=Input(paths, cast("list[str]", args.exclude), cast("Path", args.stdin_filename)),
+            input=Input(
+                paths,
+                cast("list[str]", args.exclude),
+                cast("Path", args.stdin_filename),
+                _trace(parser, cast("Path | None", args.infer_from)),
+            ),
             checks=Checks(
                 type_comments=cast("bool", args.type_comments),
                 all_scopes=cast("bool", args.all_scopes),
@@ -605,6 +617,20 @@ class Options:
         )
 
 
+def _trace(parser: argparse.ArgumentParser, path: Path | None) -> Path | None:
+    """Check that `--infer-from`'s file is a trace, read here once for the run.
+
+    Returns:
+      The path.
+
+    """
+    try:
+        _ = None if path is None else traced.load(path)
+    except ValueError as error:
+        parser.error(str(error))
+    return path
+
+
 def _maximal(args: argparse.Namespace) -> argparse.Namespace:
     """Apply `--max-fix` (`--max`, every fix, every installed checker) and `--max`.
 

{python_constricter-0.3.2 → python_constricter-0.3.3}/constricter/cli/schedule.py

@@ -13,8 +13,20 @@ from typing import Final
 
 from constricter.cli.runs import CoverageRun, FileRun
 from constricter.cli.workers import Checking, Workers, check_share, first_done
-from constricter.fix.core.known import Guarded, Hints, Outside
-from constricter.fix.index import callers, decorated, offers, order, plain, project, sides, stubbed, tuples
+from constricter.fix.core.known import Guarded, Hints, Outside, Passed
+from constricter.fix.index import (
+    beyond,
+    callers,
+    decorated,
+    fixtures,
+    offers,
+    order,
+    plain,
+    project,
+    sides,
+    stubbed,
+    tuples,
+)
 
 CYCLE_ROUNDS: Final = 3  # how many times to check again files calling each other's functions
 
@@ -26,7 +38,13 @@ def outside(modules: project.Index, path: Path, hinted: Mapping[Path, tuple[Hint
       It.
 
     """
-    imported: project.Imported = project.imported(modules, path)
+    seeded: dict[str, Guarded] = {}
+    seeds: dict[str, Passed] = fixtures.visible(modules, path, seeded)
+    imported: project.Imported = project.imported(
+        modules,
+        path,
+        (seeded, fixtures.attributes(seeds)),
+    )
     side_calls: dict[str, str]
     guarded: dict[str, Guarded]
     side_calls, guarded = sides.calls(modules, path, imported.guarded)
@@ -44,7 +62,7 @@ def outside(modules: project.Index, path: Path, hinted: Mapping[Path, tuple[Hint
         imported.generics | own.generics,
         callers.callees(modules, path),
         callers.own_parameters(modules, path),
-        {**stubbed.overloaded(modules, path), **methods.signatures},
+        {**stubbed.overloaded(modules, path, guarded), **methods.signatures},
         stubbed.classes(modules, path),
         methods.parameters,
         methods.lineage,
@@ -55,6 +73,8 @@ def outside(modules: project.Index, path: Path, hinted: Mapping[Path, tuple[Hint
         project.same(modules, path, guarded),
         imported.partial,
         tuples.fields(modules, path, guarded),
+        seeds,
+        beyond.library_bases(modules, path),
     )
 
 

python_constricter-0.3.3/constricter/cli/traced.py

@@ -0,0 +1,289 @@
+# SPDX-License-Identifier: MIT
+"""`--infer-from`: the types a traced run saw (`python -m constricter.trace`), as a type checker's hints are.
+
+A trace holds, for each file by its SHA-256, the types each function's locals held when it returned
+(see `constricter.trace`). `hints` turns a file's into `Hints`, which `--fix` judges as it does a
+checker's (`constricter.fix.values.hinted`): each a guess, of kind `traced`. Only for a local no
+annotation types: one assigned a value rooted at a parameter its function leaves unannotated
+(`row = rows[0].load()`; not `self` or `cls`). Anything else a type checker may
+type wider than the run saw (an `X | None` that was never `None`, a base class, a `TypedDict`),
+which the narrower annotation would make an error. And only one its function binds once, outside any
+loop: the trace says what it held last, not where. Up to three types seen are their union, `None`
+last.
+
+A class is shown bare, with the import that names it for type checking alone (`Offered`), unless
+the file defines it: `constricter.fix.index.offers` then takes only a class the index knows. One of
+a private module of the standard library has no hint.
+"""
+
+import ast
+import hashlib
+import json
+import re
+import sys
+from collections import Counter
+from collections.abc import Iterable, Iterator, Mapping, Sequence
+from functools import cache
+from pathlib import Path
+from typing import Final, NamedTuple, TypeAlias, cast
+
+from constricter import trace
+from constricter.fix.core.known import Hints, Offered
+from constricter.fix.values.hinted import TRACED
+
+_LABEL: Final = "a traced run"
+_SUFFIX: Final = ".py"
+_MEMBERS: Final = 3  # how many types seen make a union
+_CLASS: Final = re.compile(rf"([\w.]+){trace.SEPARATOR}(\w+)")
+_STDLIB: Final = sys.stdlib_module_names
+_TYPED: Final = frozenset({"self", "cls"})  # the parameters a class types, unannotated
+_SCOPES: Final = (
+    ast.FunctionDef,
+    ast.AsyncFunctionDef,
+    ast.ClassDef,
+    ast.Lambda,
+    ast.ListComp,
+    ast.SetComp,
+    ast.DictComp,
+    ast.GeneratorExp,
+)
+_Function: TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef
+# Each function's locals' spellings, by name, by the function's first line.
+_Functions: TypeAlias = Mapping[int, Mapping[str, tuple[str, ...]]]
+
+
+class Trace(NamedTuple):
+    """A trace file: each file's functions by its SHA-256, and the file each module named in it is."""
+
+    files: Mapping[str, _Functions]
+    modules: Mapping[str, str]
+
+
+@cache
+def load(path: Path) -> Trace:
+    """Read the trace file at `path`, once.
+
+    Returns:
+      It.
+
+    Raises:
+      ValueError: It can't be read, or isn't a trace this version reads.
+
+    """
+    try:
+        return _read(_table(cast("object", json.loads(path.read_text(encoding="utf-8")))))
+    except (OSError, ValueError) as error:
+        message: str = f"{path}: {error}"
+        raise ValueError(message) from error
+
+
+def _read(found: Mapping[str, object]) -> Trace:
+    """Read a trace file's contents.
+
+    Returns:
+      The trace, without what isn't as the recorder writes it.
+
+    Raises:
+      ValueError: It isn't a trace this version reads.
+
+    """
+    if found.get("version") != trace.VERSION:
+        message: str = f"not a trace `python -m constricter.trace` version {trace.VERSION} wrote"
+        raise ValueError(message)
+    return Trace(
+        {
+            digest: {
+                int(line): {
+                    name: tuple(cast("list[str]", types))
+                    for name, types in _table(held).items()
+                    if isinstance(types, list)
+                }
+                for line, held in _table(_table(entry).get("functions")).items()
+                if line.isdecimal()
+            }
+            for digest, entry in _table(found.get("files")).items()
+        },
+        {name: digest for name, digest in _table(found.get("modules")).items() if isinstance(digest, str)},
+    )
+
+
+def _table(value: object) -> dict[str, object]:
+    return cast("dict[str, object]", value) if isinstance(value, dict) else {}
+
+
+def merged(
+    hinted: Mapping[Path, tuple[Hints, ...]],
+    found: Trace,
+    paths: Iterable[Path],
+) -> dict[Path, tuple[Hints, ...]]:
+    """Add the trace's hints for each of `paths` after the type checkers' (`hinted`).
+
+    Returns:
+      Each file's hints.
+
+    """
+    every: dict[Path, tuple[Hints, ...]] = dict(hinted)
+    path: Path
+    for path in paths:
+        try:
+            traced: Hints | None = hints(found, path.read_bytes()) if path.suffix == _SUFFIX else None
+        except OSError:  # checking it reports that
+            continue
+        if traced is not None:
+            every[path] = (*every.get(path, ()), traced)
+    return every
+
+
+def hints(found: Trace, source: bytes) -> Hints | None:
+    """Make the hints a trace has for a file's `source`.
+
+    Returns:
+      Them; `None` for a file the trace doesn't have as it is, or has nothing for.
+
+    """
+    digest: str = hashlib.sha256(source).hexdigest()
+    functions: _Functions = found.files.get(digest, {})
+    try:
+        tree: ast.Module | None = ast.parse(source) if functions else None
+    except (SyntaxError, ValueError):
+        tree = None
+    types: dict[tuple[int, int], str] = {}
+    offered: dict[tuple[int, int], Offered] = {}
+    node: ast.AST
+    for node in ast.walk(tree) if tree is not None else ():
+        if not isinstance(node, _Function):
+            continue
+        held: Mapping[str, tuple[str, ...]] = functions.get(
+            min([node.lineno, *(decorator.lineno for decorator in node.decorator_list)]),
+            {},
+        )
+        target: ast.Name
+        for target in _untyped(node) if held else ():
+            typed: Offered | None
+            if (typed := _typed(held.get(target.id, ()), found.modules, digest)) is not None:
+                where: tuple[int, int] = (target.lineno, target.end_col_offset or 0)
+                types[where] = typed.text
+                if typed.imports:
+                    offered[where] = typed
+    return Hints(_LABEL, types, offered, TRACED) if types else None
+
+
+def _typed(spellings: Sequence[str], modules: Mapping[str, str], digest: str) -> Offered | None:
+    """Join a local's `spellings` into the annotation they make, with the imports its classes need.
+
+    `modules`, `digest`: see `Trace.modules`, and the file's own SHA-256, whose classes need none.
+
+    Returns:
+      It, or `None`: nothing seen, something that couldn't be spelled, more than `_MEMBERS` types,
+      two classes of one name, or one of a private module of the standard library.
+
+    """
+    if not spellings or trace.UNKNOWN in spellings or len(spellings) > _MEMBERS:
+        return None
+    origins: dict[str, str] = {}
+    spelling: str
+    for spelling in spellings:
+        module: str
+        name: str
+        for module, name in cast("list[tuple[str, str]]", _CLASS.findall(spelling)):
+            private: bool = module.partition(".")[0] in _STDLIB and any(
+                part.startswith("_") for part in module.split(".")
+            )
+            if private or origins.setdefault(name, module) != module:
+                return None
+    return Offered(
+        " | ".join(
+            _CLASS.sub(r"\2", spelling)
+            for spelling in sorted(spellings, key=lambda text: (text == trace.NONE, text))
+        ),
+        tuple(
+            f"from {module} import {name}"
+            for name, module in sorted(origins.items())
+            if modules.get(module) != digest
+        ),
+    )
+
+
+def _untyped(function: _Function) -> list[ast.Name]:
+    """Find the locals `function` binds once, outside any loop, to a value no annotation types.
+
+    One rooted at a parameter it leaves unannotated (`rows[0].load()`, `make(n)`; not `self` or
+    `cls`, which its class types): a type checker has no type for it either, so none to set against
+    what the run saw. Not one rooted at such a local, which a checker types by its new annotation.
+
+    Returns:
+      Each such name's binding.
+
+    """
+    args: ast.arguments = function.args
+    params: list[ast.arg] = [
+        arg
+        for arg in (*args.posonlyargs, *args.args, *args.kwonlyargs, args.vararg, args.kwarg)
+        if arg is not None
+    ]
+    others: set[str] = {arg.arg for arg in params}
+    rooted: set[str | None] = {arg.arg for arg in params if arg.annotation is None and arg.arg not in _TYPED}
+    stores: list[ast.Name] = []
+    looped: set[int] = set()  # the nodes a loop runs again
+    node: ast.AST
+    for node in _own(function):
+        if isinstance(node, ast.For | ast.AsyncFor | ast.While):
+            looped.update(id(inside) for inside in _own(node))
+        if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Store):
+            stores.append(node)
+        elif isinstance(node, ast.Global | ast.Nonlocal):
+            others.update(node.names)
+        elif isinstance(node, ast.alias):
+            others.add((node.asname or node.name).partition(".")[0])
+        elif isinstance(node, ast.ExceptHandler | ast.MatchAs | ast.MatchStar) and node.name is not None:
+            others.add(node.name)
+        elif isinstance(node, ast.MatchMapping) and node.rest is not None:
+            others.add(node.rest)
+    counts: Counter[str] = Counter(store.id for store in stores)
+    others.update(store.id for store in stores if id(store) in looped or counts[store.id] > 1)
+    return [
+        target for target, value in _assigned(function) if target.id not in others and _root(value) in rooted
+    ]
+
+
+def _assigned(function: _Function) -> Iterator[tuple[ast.Name, ast.expr]]:
+    """Find the plain assignments of one name in a function's own scope, in order.
+
+    Yields:
+      Each one's name and value.
+
+    """
+    node: ast.AST
+    for node in _own(function):
+        if isinstance(node, ast.Assign) and len(node.targets) == 1:
+            target: ast.expr = node.targets[0]
+            if isinstance(target, ast.Name):
+                yield target, node.value
+
+
+def _root(value: ast.expr) -> str | None:
+    """Find the name a value is taken from: `rows` in `rows[0].load()`, `make` in `make(n)`.
+
+    Returns:
+      It, or `None` for a value that's computed some other way.
+
+    """
+    if isinstance(value, ast.Attribute | ast.Subscript | ast.Await):
+        return _root(value.value)
+    if isinstance(value, ast.Call):
+        return _root(value.func)
+    return value.id if isinstance(value, ast.Name) else None
+
+
+def _own(node: ast.AST) -> Iterator[ast.AST]:
+    """Walk what a function's own scope holds: not what a function, class or comprehension inside it does.
+
+    Yields:
+      Each node under `node`, a nested scope's own node included.
+
+    """
+    child: ast.AST
+    for child in ast.iter_child_nodes(node):
+        yield child
+        if not isinstance(child, _SCOPES):
+            yield from _own(child)

python_constricter-0.3.3/constricter/fix/core/asked.py

@@ -0,0 +1,56 @@
+# SPDX-License-Identifier: MIT
+"""What a value was inferred to be, kept until its scope types another name.
+
+A statement's value is asked for its type, then for whether that's a guess, then as a part of the
+next value (a `with` statement's manager, three times): `asked` answers again what `keep` was told,
+for the same value (by `id`), the same scope's types (`Typed`) unchanged since, and the same number
+of imports the module's plan has added or guarded (an import `--fix` adds can resolve a name the
+next time).
+"""
+
+import ast
+from collections.abc import Mapping
+from typing import Final, TypeAlias
+
+from constricter.fix.core.known import ImportPlan, Inference, Known, Typed
+
+# What was asked: the value and the scope's types (by `id`), how often those had changed, and how
+# many imports the module's plan had added or guarded.
+_Asked: TypeAlias = tuple[int, int, int, int]
+# Its answer, with what was asked kept alive beside it: an `id` is only theirs while they live.
+_Answered: TypeAlias = tuple[ast.expr, Known, Typed, Inference | None]
+_ANSWERS: Final[dict[_Asked, _Answered]] = {}
+_KEPT: Final = 2048  # then all are dropped: a few functions' worth
+
+
+def _key(value: ast.expr, known: Known, declared: Typed) -> _Asked:
+    plan: ImportPlan | None = known.names.plan
+    return (
+        id(value),
+        id(declared),
+        declared.version,
+        0 if plan is None else len(plan.added) + len(plan.guarded),
+    )
+
+
+def asked(value: ast.expr, known: Known, declared: Mapping[str, str]) -> tuple[Inference | None] | None:
+    """Find what `value` was inferred to be, if it was asked before with nothing changed since.
+
+    Returns:
+      The inference (or `None`, for no type), in a tuple; `None` if it's yet to be worked out.
+
+    """
+    held: _Answered | None = (
+        _ANSWERS.get(_key(value, known, declared)) if isinstance(declared, Typed) else None
+    )
+    if held is None or held[0] is not value or held[1] is not known or held[2] is not declared:
+        return None
+    return (held[3],)
+
+
+def keep(value: ast.expr, known: Known, declared: Mapping[str, str], found: Inference | None) -> None:
+    """Keep what `value` was inferred to be, for a scope's own types (any other mapping may change unseen)."""
+    if isinstance(declared, Typed):
+        if len(_ANSWERS) >= _KEPT:
+            _ANSWERS.clear()
+        _ANSWERS[_key(value, known, declared)] = (value, known, declared, found)

{python_constricter-0.3.2 → python_constricter-0.3.3}/constricter/fix/core/fixes.py

@@ -10,6 +10,9 @@ from typing import Final, NamedTuple, TypeAlias
 from constricter.offences import Edit, Fix, Offence
 
 _HEADER: Final = 2  # a file's shebang and coding lines come first, if it has them
+# The last lines `_missing` read, stripped each way (see there): the lines, their count, and the set.
+_Present: TypeAlias = tuple[Sequence[str], int, frozenset[str]]
+_PRESENT: Final[dict[str | None, _Present]] = {}
 _HEADER_LINE: Final = re.compile(r"#!|#.*coding[:=]")
 # Lines to insert, and the number of lines before them.
 _Run: TypeAlias = tuple[int, list[str]]
@@ -155,8 +158,15 @@ def _missing(lines: Sequence[str], statements: Sequence[str], stripped: str | No
     """
     if not statements:  # most fixes add none: the file's lines needn't be read for them
         return []
-    present: set[str] = {line.rstrip(stripped) if stripped else line.strip() for line in lines}
-    return [statement for statement in statements if statement not in present]
+    # A file's fixes are asked one at a time, of the same lines: stripped once for them all.
+    held: _Present | None = _PRESENT.get(stripped)
+    if held is None or held[0] is not lines or held[1] != len(lines):
+        held = _PRESENT[stripped] = (
+            lines,
+            len(lines),
+            frozenset(line.rstrip(stripped) if stripped else line.strip() for line in lines),
+        )
+    return [statement for statement in statements if statement not in held[2]]
 
 
 def _import_line(lines: Sequence[str], after: int) -> int: