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

constricter/__init__.py

@@ -1,6 +1,7 @@
 # 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
 from constricter.offences import (
     COMMENT_TYPED_TARGET,
     DEFAULT_CHECKS,
@@ -25,7 +26,6 @@ from constricter.offences import (
 )
 from constricter.rules.checker import Coverage, annotation_coverage, check_source, check_tree
 
-__version__ = "0.3.6"
 __all__ = [
     "COMMENT_TYPED_TARGET",
     "DEFAULT_CHECKS",

constricter/_version.py

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

constricter/cli/collecting.py

@@ -6,15 +6,21 @@ cyclic. Left to itself, the collector looked through the kept trees again and ag
 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.
+Not on a free-threaded build, whose collector has no generations: each collection there looks through
+everything, and one after every file made a check several times as long. Its cycles wait for the run's
+end (a check of pandas held 2.9 GB so, to 2.7 GB).
 """
 
 import contextlib
 import gc
+import sysconfig
 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
+# Whether the collector has generations: a free-threaded build's has none, its GIL on or off.
+_YOUNGER: Final = not sysconfig.get_config_var("Py_GIL_DISABLED")
 
 
 @contextlib.contextmanager
@@ -44,4 +50,5 @@ def indexed() -> None:
 
 def sweep() -> None:
     """Collect what the file just checked left behind (see the module docstring)."""
-    _ = gc.collect(_YOUNG)
+    if _YOUNGER:
+        _ = gc.collect(_YOUNG)

constricter/cli/command.py

@@ -5,72 +5,43 @@ import codecs
 import contextlib
 import difflib
 import importlib
-import io
 import json
 import sys
-import tokenize
-from collections.abc import Callable, Mapping, Sequence
+from collections.abc import Callable, Sequence
 from dataclasses import replace
 from functools import partial
 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, traced
+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.protocol import HintError
+from constricter.cli.reading import encoding_of, read_text
 from constricter.cli.report import Format, Result, fix_reasons, render, statistics
-from constricter.cli.runs import Added, BaselineRun, CheckRun, CoverageRun, FileRun, merged
-from constricter.cli.workers import Workers, kept, started
+from constricter.cli.rounds import checked_all, settled
+from constricter.cli.runs import Added, BaselineRun, CheckRun, CoverageRun, FileRun
+from constricter.cli.workers import kept
 from constricter.fix.core import fixes
-from constricter.fix.core.known import Callee, Hints, Outside, Returns
-from constricter.fix.index import callers, decorated, installed, loose, plain, project
+from constricter.fix.core.known import Outside, Returns
 from constricter.noqa import lines, unsuppressed
 from constricter.offences import (
     DEFAULT_CHECKS,
     Checks,
     Edit,
-    Fix,
     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`
-    from constricter.cli import hints
+    from constricter.cli.lsp import hints
 
 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:
-    """Find the encoding of `path`, whose bytes are `data`: a notebook's is UTF-8 (it's JSON).
-
-    Returns:
-      A module's, as Python finds it: a PEP 263 declaration (`# -*- coding: latin-1 -*-`), a BOM
-      (`utf-8-sig`), or UTF-8. Raises `SyntaxError` for an unknown or contradictory one.
-
-    """
-    return (
-        "utf-8" if path.suffix == notebook.SUFFIX else tokenize.detect_encoding(io.BytesIO(data).readline)[0]
-    )
-
-
-def _read(path: Path) -> str:
-    """Read `path`, in its encoding; `-` is standard input.
-
-    Returns:
-      Its text.
-
-    """
-    if path == STDIN:
-        return sys.stdin.read()
-    data: bytes = path.read_bytes()
-    return data.decode(_encoding(path, data))
 
 
 def _source(raw: str, name: Path) -> tuple[str, list[notebook.Line]]:
@@ -128,7 +99,6 @@ def _placed(offence: Offence, where: list[notebook.Line]) -> Offence:
 
 
 # One changed part of a fixed file (the file, or a notebook's cell): its label, old and new lines.
-_Hinted: TypeAlias = dict[Path, tuple[Hints, ...]]  # each file's hints, a checker's each
 _Change: TypeAlias = tuple[str, list[str], list[str]]
 # One JSON value a coverage report holds, and one file's row of them.
 _Scalar: TypeAlias = str | int | float
@@ -180,17 +150,11 @@ def fix_file(path: Path, offences: Sequence[Offence]) -> int:
     if not (count := sum(1 for o in offences if o.edit is not None)):
         return 0
     data: bytes = path.read_bytes()
-    encoding: str = _encoding(path, data)
+    encoding: str = encoding_of(path, data)
     _ = path.write_bytes(_fixed(data.decode(encoding), path, offences).text.encode(encoding))
     return count
 
 
-HINT_ROUNDS: Final = 4  # with `--fix`: how many times a file is fixed, at most (see `_settled`)
-# The fix kinds a scope's check comes to late, once the scope is read: what was bound to such a
-# name's value before had no type yet, and has one once the fix is written.
-_LATE_KINDS: Final = frozenset({"optional", "filled"})
-
-
 def _shown_lines(raw: str, name: Path) -> dict[tuple[int | None, int], str]:
     """Map each line of `raw` (a notebook's, in its cells) to its text, as offences are placed.
 
@@ -214,7 +178,7 @@ def _checked(path: Path, name: Path, checks: Checks, outside: Outside) -> tuple[
       Its text, and what checking it found.
 
     """
-    raw: str = _read(path)
+    raw: str = read_text(path)
     return raw, checked_text(raw, name, checks, outside=outside)
 
 
@@ -360,7 +324,7 @@ 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_text(path), name)[0], options.checks))
     except (OSError, ValueError, SyntaxError) as error:
         return CoverageRun(error=f"{name}: error: {error}")
 
@@ -372,6 +336,7 @@ def _check_all(options: Options) -> tuple[list[Path], list[FileRun]]:
       The names, and what each file found.
 
     """
+    schedule.forget()
     with kept():
         return _check_rounds(options)
 
@@ -381,14 +346,16 @@ def _check_rounds(options: Options) -> tuple[list[Path], list[FileRun]]:
 
     With `--infer-with`, the type checker's server runs throughout: it's asked for every file's
     hints first, and with `--fix`, each file a round changed is asked again and checked again, as its
-    new annotations change what the checker infers (see `_settled`). A baseline records offences,
+    new annotations change what the checker infers (see `settled`). A baseline records offences,
     and coverage counts annotations: hints change neither, only what `--fix` offers.
 
     Returns:
       The names, and what each file found.
 
     """
-    paths: list[Path] = list(python_files(options.input.paths, options.input.exclude))
+    paths: list[Path] = list(
+        python_files(options.input.paths, options.input.exclude, tracked=options.input.gitignore),
+    )
     check: Callable[[Path, Outside], FileRun]
     if options.mode is Mode.COVERAGE:
         check = partial(_cover_path, options=options)
@@ -398,18 +365,19 @@ def _check_rounds(options: Options) -> tuple[list[Path], list[FileRun]]:
         check = partial(_check_path, options=options)
     names: list[Path] = [options.input.name(path) for path in paths]
     if options.mode in {Mode.COVERAGE, Mode.WRITE_BASELINE}:
-        return names, _checked_all(paths, check, options)[0]
+        return names, checked_all(paths, check, options)[0]
     if not options.infer_with:
-        return names, _settled(paths, check, options, None)
+        return names, settled(paths, check, options, None)
     session: hints.Session
     # Imported only for `--infer-with`: it's slow to import, for every run's start.
-    with cast("type[hints.Session]", importlib.import_module("constricter.cli.hints").Session)(
+    with cast("type[hints.Session]", importlib.import_module("constricter.cli.lsp.hints").Session)(
         options.infer_with,
         Path.cwd(),
         options.jobs,
         options.infer_memory,
+        kept=not options.infer_fresh,
     ) as session:
-        runs: list[FileRun] = _settled(paths, check, options, session)
+        runs: list[FileRun] = settled(paths, check, options, session)
         checker: str
         path: Path
         for checker, path in session.abandoned:
@@ -418,207 +386,6 @@ def _check_rounds(options: Options) -> tuple[list[Path], list[FileRun]]:
     return names, runs
 
 
-def _settled(
-    paths: Sequence[Path],
-    check: Callable[[Path, Outside], FileRun],
-    options: Options,
-    session: "hints.Session | None",
-) -> list[FileRun]:
-    """Check every file, then again each one `--fix` changed in a way a second check would see.
-
-    Until a round changes nothing, `HINT_ROUNDS` at most: a second pass is then left nothing.
-
-    Returns:
-      What each file found, a file's rounds joined.
-
-    """
-    runs: list[FileRun]
-    modules: project.Index
-    runs, modules = _called_again(
-        paths,
-        _checked_all(paths, check, options, session),
-        check,
-        options,
-        session,
-    )
-    again: list[int] = [
-        index
-        for index, run in enumerate(runs)
-        if options.mode is Mode.FIX and paths[index] != STDIN and _unsettled(run, session)
-    ]
-    for _ in range(HINT_ROUNDS - 1):
-        if not again:
-            break
-        redone: list[FileRun] = _checked_all([paths[i] for i in again], check, options, session, modules)[0]
-        index: int
-        run: FileRun
-        for index, run in zip(again, redone, strict=True):
-            runs[index] = merged(runs[index], run)
-        again = [index for index, run in zip(again, redone, strict=True) if _unsettled(run, session)]
-    return runs
-
-
-def _unsettled(run: FileRun, session: "hints.Session | None") -> bool:
-    """Check whether a round of `--fix` changed a file in a way that changes what's inferred there.
-
-    Returns:
-      Whether it fixed anything, with a type checker's hints: its new annotations change them.
-      Without, whether it made a fix the scope's check comes to late (`_LATE_KINDS`): what's bound
-      to such a name's value was read before its type was known.
-
-    """
-    checked: CheckRun = cast("CheckRun", run)
-    return bool(checked.fixed) and (
-        session is not None
-        or any(
-            isinstance(made.offence.edit, Fix) and made.offence.edit.kinds & _LATE_KINDS
-            for made in checked.made
-        )
-    )
-
-
-def _called_again(
-    paths: Sequence[Path],
-    first: tuple[list[FileRun], project.Index],
-    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)
-    before: project.Index = callers.with_parameters(modules, found)
-    modules = _checked_more(paths, runs, again, (check, options, session), before)
-    # A caller is checked again only if a function it imports now returns something else.
-    calling = [
-        at
-        for at in calling
-        if loose.returned(modules, paths[at], {}) != loose.returned(before, paths[at], {})
-    ]
-    return runs, _checked_more(paths, runs, calling, (check, options, session), modules)
-
-
-def _checked_more(
-    paths: Sequence[Path],
-    runs: list[FileRun],
-    which: Sequence[int],
-    how: "tuple[Callable[[Path, Outside], FileRun], Options, hints.Session | None]",
-    modules: project.Index,
-) -> project.Index:
-    """Check the files of `paths` at `which` again, knowing `modules`, into `runs`.
-
-    `how`: the check, the options and the type checkers' session. With `--fix` a file's rounds are
-    joined; otherwise the later one stands.
-
-    Returns:
-      The index, with what their functions now return.
-
-    """
-    redone: list[FileRun]
-    redone, modules = _checked_all([paths[at] for at in which], how[0], how[1], how[2], modules)
-    at: int
-    run: FileRun
-    for at, run in zip(which, redone, strict=True):
-        runs[at] = merged(runs[at], run) if how[1].mode is Mode.FIX else run
-    return 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],
-    options: Options,
-    session: "hints.Session | None" = None,
-    modules: project.Index | None = None,
-) -> tuple[list[FileRun], project.Index]:
-    """Check `paths` (`--jobs` at a time), with the `session`'s hints, and `modules` (else indexed).
-
-    Returns:
-      What each file found, and the index of every file's module.
-
-    """
-    # Before a worker starts: one forked while the servers' threads run could wait on a lock one holds.
-    hinted: _Hinted = {} if session is None else session.hints(_texts(paths))
-    if options.input.trace is not None:
-        hinted = traced.merged(hinted, traced.load(options.input.trace), paths)
-    coverage: bool = options.mode is Mode.COVERAGE  # needs nothing from the other files
-    pool: Workers | None = started(paths, options.jobs) if options.jobs != 1 and len(paths) > 1 else None
-    if modules is None and pool:
-        modules = project.Index({}, []) if coverage else pool.index()
-    elif modules is None:
-        modules = project.Index({}, []) if coverage else project.index(paths)
-        collecting.indexed()
-    if not coverage:
-        modules = plain.settled(
-            decorated.passed(installed.with_installed(modules, installed.search_path())),
-            options.checks.plain_bases,
-        )
-    return schedule.checked(
-        paths,
-        check,
-        pool,
-        (modules, hinted),
-        merged if options.mode is Mode.FIX else None,
-    )
-
-
-def _texts(paths: Sequence[Path]) -> dict[Path, str]:
-    """Read each file to ask the type checker about (not a notebook, or standard input).
-
-    A file that can't be read is left out: checking it reports that.
-
-    Returns:
-      Each file's text.
-
-    """
-    texts: dict[Path, str] = {}
-    path: Path
-    for path in paths:
-        if path != STDIN and path.suffix != notebook.SUFFIX:
-            # UnicodeDecodeError is a ValueError; a bad encoding declaration, a SyntaxError.
-            with contextlib.suppress(OSError, ValueError, SyntaxError):
-                texts[path] = _read(path)
-    return texts
-
-
 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).
 

constricter/cli/config.py

@@ -8,7 +8,7 @@ from functools import partial
 from pathlib import Path
 from typing import TYPE_CHECKING, Final, TypeAlias, cast
 
-from constricter.cli.protocol import SERVERS
+from constricter.cli.lsp.protocol import SERVERS
 from constricter.jsonc import is_int
 from constricter.offences import FIX_KINDS, LEVELS, MESSAGES, WIDEN_KINDS
 
@@ -276,6 +276,7 @@ _READERS: dict[str, Callable[[_Toml], Default | None]] = {
     "fix-plain-bases": _strings,
     "type-comments": _flag,
     "all-scopes": _flag,
+    "gitignore": _flag,
     "per-path-levels": _levels,
     "per-file-ignores": partial(_lists, read=_codes),
     "narrower": partial(_lists, read=_strings),  # a type hierarchy: each type, and those it's narrower than

constricter/cli/lsp/__init__.py

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