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

constricter/cli/command.py

@@ -9,7 +9,7 @@ import io
 import json
 import sys
 import tokenize
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Mapping, Sequence
 from dataclasses import replace
 from functools import partial
 from pathlib import Path
@@ -23,8 +23,8 @@ 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, Returns
+from constricter.fix import callers, fixes, installed, project
+from constricter.fix.known import Callee, Hints, Outside, Returns
 from constricter.noqa import lines, unsuppressed
 from constricter.offences import (
     DEFAULT_CHECKS,
@@ -41,6 +41,7 @@ EXIT_CLEAN: Final = 0
 EXIT_FOUND: Final = 1
 EXIT_ERROR: Final = 2
 _ALL: Final = 100  # percent
+_PY: Final = ".py"  # a module the index names (not a notebook)
 
 
 def _encoding(path: Path, data: bytes) -> str:
@@ -264,7 +265,11 @@ def _check_path(path: Path, outside: Outside, options: Options) -> CheckRun:
     raw, checked, error = _read_checked(path, name, options.checks, outside)
     if error:
         return CheckRun(error=error)
-    return replace(_handled(path, (raw, name), checked.offences, options), returned=checked.returned)
+    return replace(
+        _handled(path, (raw, name), checked.offences, options),
+        returned=checked.returned,
+        calls=checked.calls,
+    )
 
 
 def _handled(path: Path, text: tuple[str, Path], offences: list[Offence], options: Options) -> CheckRun:
@@ -350,8 +355,10 @@ def _check_all(options: Options) -> tuple[list[Path], list[FileRun]]:
     else:
         check = partial(_check_path, options=options)
     names: list[Path] = [options.input.name(path) for path in paths]
-    if not options.infer_with or options.mode in {Mode.COVERAGE, Mode.WRITE_BASELINE}:
+    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]
     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)(
@@ -362,7 +369,13 @@ def _check_all(options: Options) -> tuple[list[Path], list[FileRun]]:
     ) as session:
         runs: list[FileRun]
         modules: project.Index
-        runs, modules = _checked_all(paths, check, options, session)
+        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
@@ -387,6 +400,67 @@ def _check_all(options: Options) -> tuple[list[Path], list[FileRun]]:
     return names, runs
 
 
+def _called_again(
+    paths: Sequence[Path],
+    first: tuple[list[FileRun], project.Index],
+    check: Callable[[Path, Outside], FileRun],
+    options: Options,
+    session: "hints.Session | None" = None,
+) -> tuple[list[FileRun], project.Index]:
+    """Check again the files whose functions' unannotated parameters every call passes one type.
+
+    Knowing those types (see `callers`), as guesses; a file among several of one module name isn't
+    (which its callers call can't be told). Then the other files calling those functions, knowing
+    what they now return. With `--fix` a file's rounds are joined; otherwise the last, knowing more,
+    stands.
+
+    Returns:
+      What each file found, and the index, with the parameters' types.
+
+    """
+    runs: list[FileRun]
+    modules: project.Index
+    runs, modules = first
+    found: dict[str, callers.Parameters] = callers.parameters(
+        (run.calls for run in runs if isinstance(run, CheckRun)),
+        modules,
+    )
+    names: list[str | None] = [project.module_name(path) if path.suffix == _PY else None for path in paths]
+    again: list[int]
+    if not (again := [at for at, name in enumerate(names) if name in found and names.count(name) == 1]):
+        return runs, modules
+    calling: list[int] = _calling(runs, found, again)
+    modules = callers.with_parameters(modules, found)
+    which: list[int]
+    for which in (again, calling):
+        redone: list[FileRun]
+        redone, modules = _checked_all([paths[at] for at in which], check, options, session, modules)
+        at: int
+        run: FileRun
+        for at, run in zip(which, redone, strict=True):
+            runs[at] = _merged(runs[at], run) if options.mode is Mode.FIX else run
+    return runs, modules
+
+
+def _calling(
+    runs: Sequence[FileRun],
+    found: Mapping[str, callers.Parameters],
+    again: Sequence[int],
+) -> list[int]:
+    """Find the files (not among `again`) calling a function whose parameters `found` types.
+
+    Returns:
+      Their indexes.
+
+    """
+    typed: set[Callee] = {(module, function) for module, functions in found.items() for function in functions}
+    return [
+        at
+        for at, run in enumerate(runs)
+        if at not in again and isinstance(run, CheckRun) and typed & run.calls.calls.keys()
+    ]
+
+
 def _checked_all(
     paths: Sequence[Path],
     check: Callable[[Path, Outside], FileRun],
@@ -412,6 +486,8 @@ def _checked_all(
         elif modules is None:
             modules = project.Index({}, []) if coverage else project.index(paths)
             collecting.indexed()
+        if not coverage:
+            modules = installed.with_installed(modules, installed.search_path())
         return schedule.checked(
             paths,
             check,

constricter/cli/hints.py

@@ -59,6 +59,12 @@ _LINE_BREAK: Final = re.compile(r"\r\n|\r|\n")  # the lines positions count, as
 _UTF16: Final = "utf-16"
 _UTF8: Final = "utf-8"
 _METHOD_NOT_FOUND: Final = -32601
+# A request the server dropped because a document changed under it (ty, as later files open): the
+# client is to ask again.
+_CONTENT_MODIFIED: Final = -32801
+_ASK_AGAIN: Final = 5  # how many times a hint request is asked again after that, at most
+_HINTS: Final = "textDocument/inlayHint"
+_MODIFIED: Final[_Object] = {}  # a hint request's answer, when it's to be asked again (by identity)
 _ID: Final = "id"
 _METHOD: Final = "method"
 _ERROR: Final = "error"
@@ -325,14 +331,14 @@ def command(checker: str) -> list[str]:
 
     """
     server: Server = SERVERS[checker]
-    name: str = server.executable
-    executable: str | None = shutil.which(name) or shutil.which(name, path=str(Path(sys.executable).parent))
-    if executable is None:
+    found: str | None
+    if (found := protocol.executable(checker)) is None:
+        install: str = f"`pip install {checker}`"
         message: str = (
-            f"--infer-with={checker} needs `{name}`, which isn't installed (`pip install {checker}`)"
+            f"--infer-with={checker} needs `{server.executable}`, which isn't installed ({install})"
         )
         raise HintError(message)
-    return [executable, *server.args]
+    return [found, *server.args]
 
 
 class Connection:
@@ -450,32 +456,51 @@ class Connection:
         text: str
         for path, text in files.items():
             self._opened(path.resolve().as_uri(), text)
-        asked: dict[int, Path] = {
-            self._ask(
-                "textDocument/inlayHint",
-                {
-                    "textDocument": {"uri": path.resolve().as_uri()},
-                    "range": {
-                        "start": {"line": 0, "character": 0},
-                        "end": {"line": len(lines[path]), "character": 0},
-                    },
-                },
-            ): path
-            for path in files
-        }
-        return _Asked(asked, lines)
+        return _Asked({self._ask_hints(path, lines[path]): path for path in files}, lines)
+
+    def _ask_hints(self, path: Path, lines: Sequence[str]) -> int:
+        """Ask for an open file's hints over the whole of it, without waiting for them.
+
+        Returns:
+          The request's number.
+
+        """
+        return self._ask(
+            _HINTS,
+            {
+                "textDocument": {"uri": path.resolve().as_uri()},
+                "range": {"start": {"line": 0, "character": 0}, "end": {"line": len(lines), "character": 0}},
+            },
+        )
 
     def answers(self, asked: "_Asked") -> _Found:
-        """Wait for the answers to hint requests `ask` sent.
+        """Wait for the answers to hint requests `ask` sent, asking again for those the server dropped.
 
         Returns:
           Each file's variable-type hints' texts, by where the name each types ends.
 
+        Raises:
+          HintError: The server dropped one `_ASK_AGAIN` times more (see `_CONTENT_MODIFIED`).
+
         """
-        answers: dict[int, _Json] = self._collect(set(asked.numbers), "textDocument/inlayHint")
-        return {
-            path: self._found(answers[number], asked.lines[path]) for number, path in asked.numbers.items()
-        }
+        found: _Found = {}
+        waiting: dict[int, Path] = asked.numbers
+        for _ in range(_ASK_AGAIN + 1):
+            answers: dict[int, _Json] = self._collect(set(waiting), _HINTS)
+            found.update(
+                (path, self._found(answers[number], asked.lines[path]))
+                for number, path in waiting.items()
+                if answers[number] is not _MODIFIED
+            )
+            waiting = {
+                self._ask_hints(path, asked.lines[path]): path
+                for number, path in waiting.items()
+                if answers[number] is _MODIFIED
+            }
+            if not waiting:
+                return found
+        error: str = f"{self.name} failed `{_HINTS}`: content modified, {_ASK_AGAIN + 1} times"
+        raise HintError(error)
 
     def _opened(self, uri: str, text: str) -> None:
         """Send a file's text: opening it, or (open already) replacing its whole text, if it's changed."""
@@ -586,6 +611,8 @@ class Connection:
         )
         if _ERROR in answer:
             failure: _Object = cast("_Object", answer[_ERROR])
+            if method == _HINTS and failure.get("code") == _CONTENT_MODIFIED:
+                return cast("int", answer[_ID]), _MODIFIED
             error: str = f"{self.name} failed `{method}`: {failure.get('message')}"
             raise HintError(error)
         return cast("int", answer[_ID]), answer.get("result")

constricter/cli/options.py

@@ -21,7 +21,7 @@ from constricter.cli.config import (
 )
 from constricter.cli.explain import explain
 from constricter.cli.paths import STDIN, excluded
-from constricter.cli.protocol import SERVERS
+from constricter.cli.protocol import SERVERS, runs
 from constricter.cli.report import Format, Result
 from constricter.offences import (
     LEVELS,
@@ -193,6 +193,16 @@ def _parser() -> argparse.ArgumentParser:
         default="strict",
         help="which codes are errors rather than warnings (default: strict)",
     )
+    _ = parser.add_argument(
+        "--max",
+        action="store_true",
+        help="the strictest check: suffocate everywhere, all scopes, the opt-in codes (command line only)",
+    )
+    _ = parser.add_argument(
+        "--max-fix",
+        action="store_true",
+        help="--max, --fix --unsafe-fixes, and every installed checker's hints (command line only)",
+    )
     _ = parser.add_argument(
         "--format",
         type=Format,
@@ -492,7 +502,7 @@ class Options:
             parser.set_defaults(**config_defaults(Path.cwd()))
         except ValueError as error:
             parser.error(str(error))
-        args: argparse.Namespace = parser.parse_args(argv)
+        args: argparse.Namespace = _maximal(parser.parse_args(argv))
         code: str | None
         if (code := cast("str | None", args.explain)) is not None:
             _ = sys.stdout.write(explain(code))
@@ -538,6 +548,30 @@ class Options:
         )
 
 
+def _maximal(args: argparse.Namespace) -> argparse.Namespace:
+    """Apply `--max-fix` (`--max`, every fix, every installed checker) and `--max`.
+
+    `--max`: `suffocate` for every path (over `per-path-levels`), all scopes, the opt-in codes.
+
+    Returns:
+      The arguments.
+
+    """
+    if cast("bool", args.max_fix):
+        args.max = args.fix = args.unsafe_fixes = True
+        chosen: list[str] = cast("list[str]", args.infer_with)
+        args.infer_with = [
+            *chosen,
+            *(checker for checker in SERVERS if checker not in chosen and runs(checker)),
+        ]
+    if cast("bool", args.max):
+        args.level = Level.SUFFOCATE.name.lower()
+        args.per_path_levels = {}
+        args.all_scopes = True
+        args.extend_select = [*cast("list[str]", args.extend_select), *sorted(OPT_IN)]
+    return args
+
+
 def _filter(parser: argparse.ArgumentParser, args: argparse.Namespace, mode: Mode) -> Filter:
     """Build the filter the options set, reading the baseline (the default one, if it exists).
 

constricter/cli/protocol.py

@@ -6,6 +6,10 @@ type is its label after its `:`; basedpyright is asked for variable types only.
 """
 
 import json
+import shutil
+import subprocess  # asks a checker whether it runs
+import sys
+from pathlib import Path
 from typing import IO, Final, NamedTuple, TypeAlias, cast
 
 Json: TypeAlias = dict[str, "Json"] | list["Json"] | str | int | float | bool | None
@@ -44,6 +48,59 @@ SERVERS: Final = {
     # Parallel already: more servers only repeat its work (sqlalchemy's: 0.9s with one, 0.7s with four).
     "ty": Server("ty", ("server",), 1),
 }
+_PROBE: Final = "--version"  # quick for both; basedpyright-langserver's exits 1 all the same
+_PROBE_TIMEOUT: Final = 10.0  # seconds it may take
+_CANT_RUN: Final = frozenset({126, 127})  # the shell's "can't execute" and "not found": a broken shim's
+
+
+def executable(checker: str) -> str | None:
+    """Find `checker`'s language server: on `PATH`, or beside this Python (an unactivated venv).
+
+    The first that runs (a version manager's shim can be found, and not run), else the first found.
+
+    Returns:
+      Its path, or `None` if it isn't installed.
+
+    """
+    name: str = SERVERS[checker].executable
+    found: list[str] = list(
+        dict.fromkeys(
+            path
+            for path in (shutil.which(name), shutil.which(name, path=str(Path(sys.executable).parent)))
+            if path is not None
+        ),
+    )
+    return next((path for path in found if _runs(path)), found[0] if found else None)
+
+
+def runs(checker: str) -> bool:
+    """Check that `checker` is installed, and runs.
+
+    Returns:
+      Whether it does.
+
+    """
+    found: str | None = executable(checker)
+    return found is not None and _runs(found)
+
+
+def _runs(path: str) -> bool:
+    """Check that an executable runs: its `--version` starts, whatever it answers.
+
+    Returns:
+      Whether it does.
+
+    """
+    try:
+        done: subprocess.CompletedProcess[bytes] = subprocess.run(
+            [path, _PROBE],
+            capture_output=True,
+            timeout=_PROBE_TIMEOUT,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+    return done.returncode not in _CANT_RUN
 
 
 class HintError(Exception):

constricter/cli/runs.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass, field
 from typing import TypeAlias
 
 from constricter.cli.report import Result
-from constricter.fix.known import Returns
+from constricter.fix.known import Observed, Returns
 from constricter.offences import Offence
 from constricter.rules.checker import Coverage
 
@@ -20,6 +20,7 @@ class CheckRun:
     text: str = ""  # --diff: the diff; --fix on standard input: the fixed source
     error: str = ""
     returned: Returns = field(default_factory=Returns)  # what its unannotated functions return
+    calls: Observed = field(default_factory=Observed)  # what it passes checked files' functions
 
 
 @dataclass(frozen=True)

constricter/cli/schedule.py

@@ -13,7 +13,7 @@ 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 import order, project
+from constricter.fix import callers, order, project, stubbed
 from constricter.fix.known import Hints, Outside
 
 CYCLE_ROUNDS: Final = 3  # how many times to check again files calling each other's functions
@@ -27,6 +27,7 @@ def outside(modules: project.Index, path: Path, hinted: Mapping[Path, tuple[Hint
 
     """
     imported: project.Imported = project.imported(modules, path)
+    methods: stubbed.Methods = stubbed.methods(modules, path, imported.guarded)
     return Outside(
         imported.calls,
         imported.classes,
@@ -35,6 +36,13 @@ def outside(modules: project.Index, path: Path, hinted: Mapping[Path, tuple[Hint
         imported.returned,
         imported.guarded,
         imported.generics,
+        callers.callees(modules, path),
+        callers.own_parameters(modules, path),
+        {**stubbed.overloaded(modules, path), **methods.signatures},
+        stubbed.classes(modules, path),
+        methods.parameters,
+        methods.lineage,
+        methods.aliases,
     )