python-constricter 0.4.2__py3-none-any.whl → 0.4.4__py3-none-any.whl

constricter/__init__.py

@@ -1,4 +1,3 @@
-# SPDX-License-Identifier: MIT
 """Every local variable typed where it's first bound."""
 
 from constricter._version import __version__  # written by the build, from the git tag

constricter/__main__.py

@@ -1,4 +1,3 @@
-# SPDX-License-Identifier: MIT
 """`python -m constricter`, and the `constricter` script."""
 
 import contextlib
@@ -13,9 +12,10 @@ def run() -> None:
 
     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).
+    else waits on the exit (its workers have ended, its output file is closed). Nor is the collector
+    turned on again for it (`leaving`).
     """
-    status: int = main()
+    status: int = main(leaving=True)
     with contextlib.suppress(OSError, ValueError):  # a reader that left, a stream closed already
         _ = sys.stdout.flush()
         _ = sys.stderr.flush()

constricter/_version.py

@@ -1,4 +1,3 @@
-# SPDX-License-Identifier: MIT
 """The version this was built as, from its git tag (written by the build, not tracked)."""
 
-__version__ = "0.4.2"
+__version__ = "0.4.4"

constricter/cli/__init__.py

@@ -1,2 +1 @@
-# SPDX-License-Identifier: MIT
 """The `constricter` command (`command.main`): its options, the files it checks, and how it reports."""

constricter/cli/baseline.py

@@ -1,4 +1,3 @@
-# SPDX-License-Identifier: MIT
 """Baseline files: the offences a codebase already has, so only new ones are reported.
 
 An entry is a file, a code and a variable name, with how many times it occurs; line numbers aren't

constricter/cli/collecting.py

@@ -1,4 +1,3 @@
-# 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
@@ -24,9 +23,12 @@ _YOUNGER: Final = not sysconfig.get_config_var("Py_GIL_DISABLED")
 
 
 @contextlib.contextmanager
-def by_hand() -> Generator[None]:
+def by_hand(*, leaving: bool = False) -> Generator[None]:
     """Turn automatic collection off for the command's run, and back as it was after.
 
+    Not for a process that leaves once the run's done (`leaving`): turned on again, the collector
+    looked through all the run left alive, at once (a check of pandas: 3.4s, for nothing).
+
     Yields:
       Nothing: the run.
 
@@ -36,9 +38,9 @@ def by_hand() -> Generator[None]:
     try:
         yield
     finally:
-        if _FREEZES:
+        if _FREEZES and not leaving:
             gc.unfreeze()
-        if was:
+        if was and not leaving:
             gc.enable()
 
 

constricter/cli/command.py

@@ -1,4 +1,3 @@
-# SPDX-License-Identifier: MIT
 """The `constricter` command (see README)."""
 
 import codecs
@@ -18,7 +17,7 @@ from constricter.cli import baseline, collecting, schedule
 from constricter.cli.lsp.protocol import HintError
 from constricter.cli.options import Mode, Options, Output
 from constricter.cli.paths import STDIN, python_files
-from constricter.cli.reading import encoding_of, read_text
+from constricter.cli.reading import READ_ERRORS, encoding_of, read_text
 from constricter.cli.report import Format, Result, fix_reasons, render, statistics
 from constricter.cli.rounds import checked_all, settled
 from constricter.cli.runs import Added, BaselineRun, CheckRun, CoverageRun, FileRun
@@ -32,16 +31,17 @@ from constricter.offences import (
     Edit,
     Offence,
 )
-from constricter.rules import parsed
 from constricter.rules.checker import Checked, Coverage, annotation_coverage, checked_source
+from constricter.source import parsed
 
 if TYPE_CHECKING:  # slow to import, and only needed for `--infer-with`
+    from types import ModuleType
+
     from constricter.cli.lsp import hints
 
 EXIT_CLEAN: Final = 0
 EXIT_FOUND: Final = 1
 EXIT_ERROR: Final = 2
-_ALL: Final = 100  # percent
 
 
 def _source(raw: str, name: Path) -> tuple[str, list[notebook.Line]]:
@@ -198,11 +198,21 @@ def _read_checked(
     checked: Checked
     try:
         raw, checked = _checked(path, name, checks, outside)
-    except (OSError, ValueError, SyntaxError) as error:  # UnicodeDecodeError is a ValueError
-        return "", Checked([], Returns()), f"{name}: error: {error}"
+    except READ_ERRORS as error:
+        return "", Checked([], Returns()), _error(name, error)
     return raw, checked, ""
 
 
+def _error(name: Path, error: Exception) -> str:
+    """Say why a file couldn't be read or parsed.
+
+    Returns:
+      The message.
+
+    """
+    return f"{name}: error: {error}"
+
+
 def _results(raw: str, name: Path, offences: Sequence[Offence], options: Options) -> list[Result]:
     """Turn the offences in `raw`, the text of `name`, into the results to report.
 
@@ -325,8 +335,8 @@ def _cover_path(path: Path, _outside: Outside, options: Options) -> CoverageRun:
     name: Path = options.input.name(path)
     try:
         return CoverageRun(annotation_coverage(_source(read_text(path), name)[0], options.checks))
-    except (OSError, ValueError, SyntaxError) as error:
-        return CoverageRun(error=f"{name}: error: {error}")
+    except READ_ERRORS as error:
+        return CoverageRun(error=_error(name, error))
 
 
 def _check_all(options: Options) -> tuple[list[Path], list[FileRun]]:
@@ -370,12 +380,17 @@ def _check_rounds(options: Options) -> tuple[list[Path], list[FileRun]]:
         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.lsp.hints").Session)(
+    hinting: ModuleType = importlib.import_module("constricter.cli.lsp.hints")
+    asking: hints.Asking = cast("type[hints.Asking]", hinting.Asking)(
+        kept=not options.infer_fresh,
+        in_turn=options.infer_in_turn,
+    )
+    with cast("type[hints.Session]", hinting.Session)(
         options.infer_with,
         Path.cwd(),
         options.jobs,
         options.infer_memory,
-        kept=not options.infer_fresh,
+        asking,
     ) as session:
         runs: list[FileRun] = settled(paths, check, options, session)
         checker: str
@@ -383,6 +398,11 @@ def _check_rounds(options: Options) -> tuple[list[Path], list[FileRun]]:
         for checker, path in session.abandoned:
             name: Path = options.input.name(path)
             _ = sys.stderr.write(f"constricter: warning: {checker} hung on {name} twice: no hints for it\n")
+        read: int
+        rounds: int
+        for checker, read, rounds in session.reused:
+            told: str = f"{checker}'s hints for {read} of {rounds} rounds were read from the store"
+            _ = sys.stderr.write(f"constricter: note: {told} (`--infer-fresh` asks again)\n")
     return names, runs
 
 
@@ -485,8 +505,8 @@ def _typed(found: Coverage) -> str:
     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.
+def _run(options: Options, *, leaving: bool) -> int:
+    """Check, fix, diff, count or baseline, printing what that finds (`leaving`: see `main`).
 
     Returns:
       The exit status.
@@ -494,7 +514,7 @@ def _run(options: Options) -> int:
     """
     names: list[Path]
     runs: list[FileRun]
-    with collecting.by_hand():
+    with collecting.by_hand(leaving=leaving):
         try:
             names, runs = _check_all(options)
         except HintError as error:
@@ -527,9 +547,12 @@ def _run(options: Options) -> int:
     return EXIT_ERROR if failed else status
 
 
-def main(argv: Sequence[str] | None = None) -> int:
+def main(argv: Sequence[str] | None = None, *, leaving: bool = False) -> int:
     """Run the command.
 
+    `leaving`: the process leaves once it's done (`constricter.__main__.run`), its collector as the
+    run left it (see `collecting.by_hand`).
+
     Returns:
       Its exit status.
 
@@ -543,5 +566,5 @@ def main(argv: Sequence[str] | None = None) -> int:
         else contextlib.nullcontext(sys.stdout) as stream,
         contextlib.redirect_stdout(stream),
     ):
-        status: int = _run(options)
+        status: int = _run(options, leaving=leaving)
     return EXIT_CLEAN if options.output.exit_zero and status == EXIT_FOUND else status

constricter/cli/config.py

@@ -1,4 +1,3 @@
-# SPDX-License-Identifier: MIT
 """The command's defaults, from the nearest `pyproject.toml`'s `[tool.constricter]` table."""
 
 import re
@@ -221,11 +220,13 @@ def _checkers(value: _Toml) -> list[str] | None:
     """Read `infer-with`: a checker, or a list of them, each one it knows.
 
     Returns:
-      Them, or `None` for anything else.
+      Them, each once in the order they're preferred, as `--infer-with` gives them; `None` for
+      anything else.
 
     """
     checkers: list[str] | None = [value] if isinstance(value, str) else _strings(value)
-    return checkers if checkers and all(checker in SERVERS for checker in checkers) else None
+    known: bool = bool(checkers) and all(checker in SERVERS for checker in checkers or ())
+    return list(dict.fromkeys(checkers)) if checkers and known else None
 
 
 def _levels(value: _Toml) -> dict[str, str] | None:
@@ -248,7 +249,7 @@ def _lists(value: _Toml, read: Callable[[_Toml], list[str] | None]) -> dict[str,
     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:
+def _path(value: _Toml, root: Path) -> str | None:
     """Read a baseline's or a trace's path, relative to `root` (the pyproject.toml that names it).
 
     Returns:
@@ -303,8 +304,8 @@ def config_defaults(start: Path) -> dict[str, Default]:
         return {}
     readers: dict[str, Callable[[_Toml], Default | None]] = {
         **_READERS,
-        "baseline": partial(_baseline, root=path.parent),
-        "infer-from": partial(_baseline, root=path.parent),
+        "baseline": partial(_path, root=path.parent),
+        "infer-from": partial(_path, root=path.parent),
     }
     defaults: dict[str, Default] = {}
     key: str

constricter/cli/explain.py

@@ -1,4 +1,3 @@
-# SPDX-License-Identifier: MIT
 """Each code's rationale and fix, for `constricter --explain`."""
 
 from typing import Final
@@ -14,7 +13,10 @@ from constricter.offences import (
     OPT_IN,
     REDUNDANT_TYPE,
     UNANNOTATED,
+    UNANNOTATED_ATTRIBUTE,
     UNANNOTATED_MEMBER,
+    UNANNOTATED_PARAMETER,
+    UNANNOTATED_RETURN,
     UNTYPED_TARGET,
     UNUSED_UNION_MEMBER,
     VAGUE_TYPE,
@@ -83,6 +85,24 @@ _WHY: Final = {
         "(not from a nested function either) could say so: `limit: Final = 10`. Off unless selected\n"
         "by its full code (`--extend-select LVA012`): most locals are bound once."
     ),
+    UNANNOTATED_ATTRIBUTE: (
+        "An instance attribute a plain class's method first stores (`self.count = 0`), declared\n"
+        "nowhere in the class, is typed by whatever a type checker infers from that store. Annotate\n"
+        "it there: `self.count: int = 0`. Off unless selected by its full code (`--extend-select LVA013`)."
+    ),
+    UNANNOTATED_RETURN: (
+        "A plain function with no return annotation leaves its callers to whatever a type checker\n"
+        "infers. `--fix` writes what its own `return`s give (`-> int`), or `-> None` for one that\n"
+        "returns nothing. Off unless selected by its full code (`--extend-select LVA014`): ruff's ANN201\n"
+        "reports it too; this is for the fix."
+    ),
+    UNANNOTATED_PARAMETER: (
+        "A parameter with no annotation leaves the function's body to whatever a type checker\n"
+        "infers of it. `--fix` writes what typed it from outside, a guess: what every call passes it,\n"
+        "the one class with every member the function reads of it, its pytest fixture's value, or\n"
+        "the one type the checked files annotate its name with. Off unless selected by its full code\n"
+        "(`--extend-select LVA015`): ruff's ANN001 reports it too; this is for the fix."
+    ),
 }
 
 

constricter/cli/lsp/__init__.py

@@ -1,2 +1 @@
-# SPDX-License-Identifier: MIT
 """constricter.cli.lsp."""

constricter/cli/lsp/connection.py

@@ -1,4 +1,3 @@
-# SPDX-License-Identifier: MIT
 """A running language server, and the JSON-RPC conversation with it (`Connection`), for `hints`.
 
 The files it has open, the hint requests sent and not yet answered, and what it has said.
@@ -6,7 +5,6 @@ The files it has open, the hint requests sent and not yet answered, and what it
 
 import contextlib
 import itertools
-import json
 import os
 import queue
 import re
@@ -22,7 +20,7 @@ from pathlib import Path
 from typing import IO, Final, NamedTuple, TypeAlias, cast
 
 from constricter.cli.lsp import edits, guard, protocol
-from constricter.cli.lsp.protocol import HintError, HungError
+from constricter.cli.lsp.protocol import ExitedError, HintError, HungError
 from constricter.fix.core.known import Offered
 
 _Json: TypeAlias = protocol.Json
@@ -79,22 +77,24 @@ class _Documents:
     texts: dict[str, str] = field(default_factory=dict[str, str])
 
 
-class _Asked(NamedTuple):
+class Asked(NamedTuple):
     """Hint requests sent, not yet answered: each request's file, and each file's lines."""
 
     numbers: dict[int, Path]
     lines: dict[Path, list[str]]
 
 
-Sent: TypeAlias = tuple[dict[Path, str], _Asked]  # a batch of files, and its hint requests
+Sent: TypeAlias = tuple[dict[Path, str], Asked]  # a batch of files, and its hint requests
 
 
 class Connection:
     """A running language server, and the JSON-RPC conversation with it."""
 
-    def __init__(self, argv: Sequence[str], root: Path) -> None:
+    def __init__(self, argv: Sequence[str], root: Path, environment: Mapping[str, str] | None = None) -> None:
         """Start the server (`argv`) and initialize it, with `root` as its one workspace folder.
 
+        In `environment`, or else this process's.
+
         Raises:
           HintError: It can't be started, or fails to initialize.
 
@@ -115,6 +115,7 @@ class Connection:
                 stdout=subprocess.PIPE,
                 stderr=subprocess.DEVNULL,
                 cwd=root,
+                env=environment,
             ),
         )
         self.inbox: _Inbox = _Inbox()
@@ -188,7 +189,7 @@ class Connection:
             return False
         return True
 
-    def ask(self, files: Mapping[Path, str]) -> "_Asked":
+    def ask(self, files: Mapping[Path, str]) -> "Asked":
         """Open each file (or send its new text), and ask for its hints over the whole of it.
 
         It doesn't wait for them. Each file is left open: basedpyright (1.40) fails the next file's
@@ -204,7 +205,7 @@ class Connection:
         text: str
         for path, text in files.items():
             self._opened(path.resolve().as_uri(), text)
-        return _Asked({self._ask_hints(path, lines[path]): path for path in files}, 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.
@@ -221,7 +222,7 @@ class Connection:
             },
         )
 
-    def answers(self, asked: "_Asked") -> Found:
+    def answers(self, asked: "Asked") -> Found:
         """Wait for the answers to hint requests `ask` sent, asking again for those the server dropped.
 
         Returns:
@@ -327,7 +328,7 @@ class Connection:
 
         """
         self.last += 1
-        self._send({"jsonrpc": "2.0", _ID: self.last, _METHOD: method, "params": params})
+        self._send({_ID: self.last, _METHOD: method, "params": params})
         return self.last
 
     def _collect(self, numbers: set[int], method: str) -> dict[int, _Json]:
@@ -391,7 +392,7 @@ class Connection:
           It.
 
         Raises:
-          HintError: The server exited, or took too long.
+          ExitedError: The server exited (`_waited` raises `HungError` where it took too long).
 
         """
         # `_waited` raises rather than end: there is always a next message, or an error.
@@ -400,7 +401,7 @@ class Connection:
         )
         if message is None:
             error: str = f"{self.name} exited while answering `{method}`"
-            raise HintError(error)
+            raise ExitedError(error)
         return message
 
     def _waited(self, method: str) -> _Object | None:
@@ -442,7 +443,7 @@ class Connection:
     def _answer(self, message: _Object) -> None:
         """Answer one of the server's own requests: its settings, and nothing else it asks for."""
         method: str = str(message[_METHOD])
-        reply: _Object = {"jsonrpc": "2.0", _ID: message[_ID]}
+        reply: _Object = {_ID: message[_ID]}
         if method == _CONFIGURATION:
             items: list[_Json] = cast("list[_Json]", cast("_Object", message["params"])["items"])
             reply["result"] = [protocol.settings(cast("_Object", item).get("section")) for item in items]
@@ -454,22 +455,18 @@ class Connection:
 
     def notify(self, method: str, params: _Json) -> None:
         """Send a notification: no answer comes."""
-        self._send({"jsonrpc": "2.0", "method": method, "params": params})
+        self._send({"method": method, "params": params})
 
     def _send(self, message: _Object) -> None:
-        """Frame and send one message.
+        """Frame and send one message (see `protocol.write`).
 
         Raises:
-          HintError: The server has exited.
+          ExitedError: The server has exited.
 
         """
-        body: bytes = json.dumps(message).encode()
         with self.writing:  # one message at a time: the reader answers the server's own meanwhile
             try:
-                protocol.write(
-                    cast("IO[bytes]", self.process.stdin),
-                    f"Content-Length: {len(body)}\r\n\r\n".encode() + body,
-                )
+                protocol.write(cast("IO[bytes]", self.process.stdin), message)
             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
+                raise ExitedError(failure) from error

constricter/cli/lsp/edits.py

@@ -1,4 +1,3 @@
-# SPDX-License-Identifier: MIT
 """`--infer-with`: what a hint's own edits would write (see `Offered`).
 
 An editor that accepts an inlay hint applies its `textEdits`: the annotation, spelled as the file can
@@ -20,7 +19,7 @@ from urllib.request import url2pathname
 from constricter.cli.lsp.protocol import Json, Object
 from constricter.fix.core.known import Offered
 from constricter.fix.index.modules import SUFFIX, module_name
-from constricter.rules import parsed
+from constricter.source import parsed
 
 _Where: TypeAlias = tuple[int, int]  # a line (from 1) and a UTF-8 byte column, as `ast` counts
 _Locate: TypeAlias = Callable[[Object], _Where | None]  # a position's, or `None` past the file's end

constricter/cli/lsp/guard.py

@@ -1,7 +1,6 @@
-# SPDX-License-Identifier: MIT
 """Run a type checker's language server for `--infer-with`, so it can't outlive constricter.
 
-  python .../constricter/cli/guard.py GRACE EXECUTABLE [ARGUMENT ...]
+  python .../constricter/cli/lsp/guard.py GRACE EXECUTABLE [ARGUMENT ...]
 
 It imports only the standard library, so it runs by its path whatever the Python can import.
 
@@ -66,20 +65,23 @@ def main(argv: Sequence[str], stdin: IO[bytes] | None = None, stdout: IO[bytes]
 
 def _pass_on(source: IO[bytes], target: IO[bytes]) -> None:
     """Pass the server's output on until it ends (or constricter's end of it has gone)."""
-    chunk: bytes
     with contextlib.suppress(OSError):
-        for chunk in iter(lambda: _read(source), b""):
-            _write(target, chunk)
+        _copied(source, target)
+
+
+def _copied(source: IO[bytes], target: IO[bytes]) -> None:
+    """Copy `source` to `target` until it ends, each chunk as it comes: the reader waits on it."""
+    chunk: bytes
+    for chunk in iter(lambda: _read(source), b""):
+        _write(target, chunk)
 
 
 def relay_to(source: IO[bytes], server: "subprocess.Popen[bytes]", grace: float) -> None:
     """Pass `source` on to the server's input; when it ends, end the server's, and give it `grace` seconds."""
     target: IO[bytes] = cast("IO[bytes]", server.stdin)
-    chunk: bytes
     # The server has gone (or this is exiting, its input closed): nothing more to pass on.
     with contextlib.suppress(OSError, ValueError):
-        for chunk in iter(lambda: _read(source), b""):
-            _write(target, chunk)
+        _copied(source, target)
     with contextlib.suppress(OSError):  # what's left for a server that has gone is dropped
         target.close()
     try: