crapkit 0.7.3__tar.gz → 0.7.4__tar.gz

{crapkit-0.7.3/src/crapkit.egg-info → crapkit-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crapkit
-Version: 0.7.3
+Version: 0.7.4
 Summary: Scores every function on complexity times uncovered risk, ranks the worst, and blocks commits that add more.
 Author: Jean-Francois Gagne
 License: MIT
@@ -199,7 +199,7 @@ files. Review those commands before running Crapkit in a repository you do not t
 
 ```
 $ crapkit --version
-crapkit 0.7.3
+crapkit 0.7.4
 ```
 
 `python -m crapkit` works identically to the console script and is what to use from a
@@ -455,7 +455,7 @@ crapkit ships a `.pre-commit-hooks.yaml` declaring `id: crapkit-gate`. In your
 repos:
   - repo: https://github.com/JeanFrancoisGagne/crapkit
     # crapkit's release step rewrites this line to the tag it just cut
-    rev: v0.7.3
+    rev: v0.7.4
     hooks:
       - id: crapkit-gate
 ```
@@ -563,7 +563,7 @@ to a workflow, and every input has a default:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - uses: JeanFrancoisGagne/crapkit@v0.7.3
+      - uses: JeanFrancoisGagne/crapkit@v0.7.4
 ```
 
 The whole job those four lines sit in:
@@ -583,7 +583,7 @@ jobs:
         with:
           python-version: "3.12"       # the interpreter the install below lands in
       - run: pip install -e ".[dev]"   # whatever your lanes need to run
-      - uses: JeanFrancoisGagne/crapkit@v0.7.3
+      - uses: JeanFrancoisGagne/crapkit@v0.7.4
         with:
           gate: "false"
 ```

{crapkit-0.7.3 → crapkit-0.7.4}/README.md

@@ -158,7 +158,7 @@ files. Review those commands before running Crapkit in a repository you do not t
 
 ```
 $ crapkit --version
-crapkit 0.7.3
+crapkit 0.7.4
 ```
 
 `python -m crapkit` works identically to the console script and is what to use from a
@@ -414,7 +414,7 @@ crapkit ships a `.pre-commit-hooks.yaml` declaring `id: crapkit-gate`. In your
 repos:
   - repo: https://github.com/JeanFrancoisGagne/crapkit
     # crapkit's release step rewrites this line to the tag it just cut
-    rev: v0.7.3
+    rev: v0.7.4
     hooks:
       - id: crapkit-gate
 ```
@@ -522,7 +522,7 @@ to a workflow, and every input has a default:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - uses: JeanFrancoisGagne/crapkit@v0.7.3
+      - uses: JeanFrancoisGagne/crapkit@v0.7.4
 ```
 
 The whole job those four lines sit in:
@@ -542,7 +542,7 @@ jobs:
         with:
           python-version: "3.12"       # the interpreter the install below lands in
       - run: pip install -e ".[dev]"   # whatever your lanes need to run
-      - uses: JeanFrancoisGagne/crapkit@v0.7.3
+      - uses: JeanFrancoisGagne/crapkit@v0.7.4
         with:
           gate: "false"
 ```

{crapkit-0.7.3 → crapkit-0.7.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "crapkit"
-version = "0.7.3"
+version = "0.7.4"
 description = "Scores every function on complexity times uncovered risk, ranks the worst, and blocks commits that add more."
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { text = "MIT" }

{crapkit-0.7.3 → crapkit-0.7.4}/src/crapkit/__init__.py

@@ -1,2 +1,2 @@
 """crapkit: deterministic CRAP-score framework."""
-__version__ = "0.7.3"
+__version__ = "0.7.4"

{crapkit-0.7.3 → crapkit-0.7.4}/src/crapkit/analyze.py

@@ -19,8 +19,10 @@ from ._pygdefer import deferred_pygments
 with deferred_pygments():  # lizard's Erlang reader would load pygments here
     import lizard
     from lizard_languages import get_reader_for as _lizard_reader_for
+    from lizard_languages.python import PythonReader as _PythonReader
 
     from .lizardpowershell import register as _register_powershell
+    from .lizardpython import register as _register_python
     from .lizardrust import register as _register_rust
     from .lizardshell import register as _register_shell
     from .lizardtypescript import LizardExtension as _TypeScriptExpressions
@@ -34,18 +36,22 @@ from .packet import bare_name
 
 # lizard picks a reader by extension off a hardcoded list, and none of these is
 # on it: `.rs` resolves to a reader that counts no `match` arm (lizard #494),
-# and `.sh` and `.ps1` resolve to nothing at all, which lizard answers with
-# CLikeReader rather than a failure. All three belong HERE, at the module scope
-# of the module a ProcessPoolExecutor child imports, or spawned workers measure
-# with the readers lizard shipped and report plausible wrong numbers.
+# `.py` to one that ends a def inside a signature that runs past its first `)`
+# (crapkit #72), and `.sh` and `.ps1` resolve to nothing at all, which lizard
+# answers with CLikeReader rather than a failure. All four belong HERE, at the
+# module scope of the module a ProcessPoolExecutor child imports, or spawned
+# workers measure with the readers lizard shipped and report plausible wrong
+# numbers.
 #
-# lizardshell and lizardpowershell already register themselves on import and
-# lizardrust deliberately does not (rebinding a name in another package's
-# namespace is not something an import should do quietly). Calling all three
-# keeps the wiring readable in one place and costs nothing: each is idempotent.
+# lizardshell and lizardpowershell already register themselves on import, and
+# lizardrust and lizardpython deliberately do not (rebinding a name in another
+# package's namespace is not something an import should do quietly). Calling
+# all four keeps the wiring readable in one place and costs nothing: each is
+# idempotent.
 _register_rust()
 _register_shell()
 _register_powershell()
+_register_python()
 
 _POOL_THRESHOLD = 16
 
@@ -145,6 +151,67 @@ class _CreationOrder:
             context.try_new_function = original
 
 
+# --- a Python def no reader finished (#72) -----------------------------------------
+#
+# lizard 1.24.0's PythonReader ended a def inside its own signature when the
+# signature ran past its first `)`: a return annotation opened on the def line,
+# or a line break after a default such as `()`. The def read as two lines at ccn
+# 1 whatever its body held and passed every gate on that reading.
+# crapkit.lizardpython reads those signatures to the body's colon. Measured on
+# 6,866 stdlib, site-packages and openclaw files: all 59 defs lizard cut off read
+# their full span, and of the defs lizard read whole only the 20 nested inside a
+# cut-off def changed, each gaining its parent's name as a prefix (one of them
+# also scores 1 lower on cognitive).
+#
+# This check stays as the net under that reader. A def read to its body has a
+# `:` at bracket depth 0 with a token after it; one cut off in its signature has
+# not. A def the reader still cannot finish is refused, never scored at ccn 1.
+_OPENERS = frozenset("([{")
+_CLOSERS = frozenset(")]}")
+
+
+def _step_body(fn, token: str) -> None:
+    """Advance one function's signature reading by one of its own tokens.
+
+    `crapkit_body` is False from the name token on and True from the first
+    token after the body colon. A function some other reader produced never
+    gets the attribute, which is what keeps `_unread_defs` to Python.
+    """
+    if getattr(fn, "crapkit_colon", False):
+        fn.crapkit_body = True
+        return
+    fn.crapkit_body = False
+    depth = getattr(fn, "crapkit_depth", 0)
+    if token in _OPENERS:
+        fn.crapkit_depth = depth + 1
+    elif token in _CLOSERS:
+        fn.crapkit_depth = depth - 1
+    elif token == ":" and depth == 0:
+        fn.crapkit_colon = True
+
+
+class _PythonBodies:
+    """Mark every Python function whose body lizard reached.
+
+    Reads a token's owner after lizard has, the way the cognitive pass does:
+    the name token is what creates the function, and the line that ends one
+    was charged to its parent by `preprocess`, upstream of here, before the
+    token arrived. Sits behind `line_counter`, so no whitespace or newline
+    token reaches it and any token after the body colon is body.
+    """
+
+    def __call__(self, tokens, reader):
+        if not isinstance(reader, _PythonReader):
+            yield from tokens
+            return
+        context = reader.context
+        for token in tokens:
+            yield token
+            fn = context.current_function
+            if fn is not context.global_pseudo_function:
+                _step_body(fn, token)
+
+
 def _chain(cognitive_index: int) -> list:
     """lizard's standard extensions with cognitive spliced in at one index.
 
@@ -155,7 +222,7 @@ def _chain(cognitive_index: int) -> list:
     """
     extensions = lizard.get_extensions(["ND"])
     extensions.insert(cognitive_index, _Cognitive())
-    return [_TypeScriptExpressions(), *extensions, _ModifiedDelta(), _CreationOrder()]
+    return [_TypeScriptExpressions(), *extensions, _ModifiedDelta(), _PythonBodies(), _CreationOrder()]
 
 
 # Two chains, built once per process each, not once per file: 14k files paid 14k
@@ -279,6 +346,35 @@ def _file_records(rel_path: str, functions) -> list[FunctionRecord]:
     return [_record(rel_path, fn, occurrences[id(fn)]) for fn in functions]
 
 
+def _unread_defs(functions) -> list:
+    """The Python functions `_PythonBodies` never saw a body token for."""
+    return [fn for fn in functions if getattr(fn, "crapkit_body", True) is False]
+
+
+def _unread_reason(rel_path: str, unread: list) -> str:
+    named = ", ".join(f"{rel_path}:{fn.start_line} {fn.long_name}" for fn in unread)
+    return (f"{rel_path}: the Python reader reached no body for {len(unread)} def(s): {named}; "
+            f"a def read no further than its signature would score ccn 1 whatever its body "
+            f"holds, so the file is not scored. Check that the file parses (a signature cut "
+            f"off at the end of the file reads this way); if it does, report the signature at "
+            f"https://github.com/JeanFrancoisGagne/crapkit/issues")
+
+
+def _trusted_records(rel_path: str, functions) -> list[FunctionRecord]:
+    """Records for a file every function of which was read to its body.
+
+    A file with a def the reader never finished takes the unanalyzable road,
+    named on every run and scored as zero functions, not a ccn-1 reading of
+    that def: scoring it would pass the gate on a number that means nothing,
+    and ending the run over one file is what 0.7.1 stopped (_note_unanalyzable).
+    Every such def in the file is named at once.
+    """
+    unread = _unread_defs(functions)
+    if unread:
+        return UnanalyzableFile(_unread_reason(rel_path, unread))
+    return _file_records(rel_path, functions)
+
+
 # --- how a source file's bytes become text -------------------------------------
 #
 # lizard opens a source file with `io.open(path, 'r')` and no encoding, so the
@@ -374,7 +470,7 @@ def analyze_one(args: tuple[str, str]) -> tuple[str, list[FunctionRecord]]:
     abs_path, rel_path = args
     try:
         analysis = lizard.FileAnalyzer(_extensions_for(rel_path))(abs_path)
-        return rel_path, _file_records(rel_path, analysis.function_list)
+        return rel_path, _trusted_records(rel_path, analysis.function_list)
     except Exception as exc:  # loud and counted, never fatal: see _note_unanalyzable
         return rel_path, UnanalyzableFile(f"lizard failed on {rel_path}: {exc}")
 
@@ -390,9 +486,10 @@ def analyze_source(rel_path: str, code: str) -> list[FunctionRecord]:
     try:
         analyzer = lizard.FileAnalyzer(_extensions_for(rel_path))
         analysis = analyzer.analyze_source_code(rel_path, code)
-        records = _file_records(rel_path, analysis.function_list)
+        records = _trusted_records(rel_path, analysis.function_list)
     except Exception as exc:  # per-file, exactly as in analyze_one; the hook keeps going
         records = UnanalyzableFile(f"lizard failed on {rel_path}: {exc}")
+    if isinstance(records, UnanalyzableFile):
         _note_unanalyzable({rel_path: records})
         return records
     _note_twin_keys(rel_path, records)
@@ -640,7 +737,7 @@ def _analyze_verified(job: tuple[str, str, str]) -> tuple[str, list[FunctionReco
     try:
         analyzer = lizard.FileAnalyzer(_extensions_for(relative))
         analysis = analyzer.analyze_source_code(relative, decode_source(raw))
-        return relative, _file_records(relative, analysis.function_list)
+        return relative, _trusted_records(relative, analysis.function_list)
     except Exception as exc:  # a parse refusal, unlike the read and hash above, is per-file
         return relative, UnanalyzableFile(f"lizard failed on {relative}: {exc}")
 

{crapkit-0.7.3 → crapkit-0.7.4}/src/crapkit/cli/admin.py

@@ -996,14 +996,16 @@ def _newest_coverage_run(store: SnapshotStore) -> dict | None:
 @dataclass
 class _DirCount:
     """One directory's share of a run: how many functions it holds, how many of
-    them carry a verdict other than untested, and the file stems to match on."""
+    them carry a verdict other than untested, and the file stems and language
+    families to match on."""
     functions: int = 0
     others: int = 0
     stems: set = field(default_factory=set)
+    families: set = field(default_factory=set)
 
 
 def _dirs_from_counts(counts: list[tuple]) -> dict[str, _DirCount]:
-    from ..doctor import _dir_of, _stem_of
+    from ..doctor import _dir_of, _family_of, _stem_of
 
     dirs: dict[str, _DirCount] = {}
     for path, functions, others in counts:
@@ -1011,6 +1013,7 @@ def _dirs_from_counts(counts: list[tuple]) -> dict[str, _DirCount]:
         entry.functions += functions
         entry.others += others
         entry.stems.add(_stem_of(path))
+        entry.families.add(_family_of(path))
     return dirs
 
 
@@ -1021,12 +1024,13 @@ def _unmeasured_gaps(counts: list[tuple], tracked: list[str]) -> tuple:
     it carries a verdict other than untested and a tracked test file names its
     code. The matching itself stays doctor's, so the mirror rule has one copy.
     """
-    from ..doctor import UnmeasuredDir, _matching_test, _test_files
+    from ..doctor import UnmeasuredDir, _matching_test, _tests_by_family
 
-    test_files = _test_files(tracked)
+    test_files = _tests_by_family(tracked)
     found = []
     for directory, stats in sorted(_dirs_from_counts(counts).items()):
-        example = _matching_test(directory, stats.stems, test_files) if not stats.others else None
+        example = _matching_test(directory, stats.stems, stats.families, test_files) \
+            if not stats.others else None
         if example:
             found.append(UnmeasuredDir(directory, stats.functions, example))
     return tuple(found)

{crapkit-0.7.3 → crapkit-0.7.4}/src/crapkit/doctor.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import NamedTuple
 
-from .universe import scopes_with_tests
+from .universe import LANGUAGE_EXTENSIONS, scopes_with_tests
 
 from .config_contract import known_keys
 
@@ -242,6 +242,7 @@ class _DirStats:
     functions: int = 0
     flags: set = field(default_factory=set)
     stems: set = field(default_factory=set)
+    families: set = field(default_factory=set)
 
 
 _TEST_DIR_PARTS = frozenset({"test", "tests", "__tests__", "spec", "specs"})
@@ -255,12 +256,31 @@ def _stem_of(path: str) -> str:
     return path.rsplit("/", 1)[-1].split(".")[0]
 
 
+# One family per coverage parser, not one per lizard reader: a vitest run
+# measures .ts, .tsx, .js and the .vue components beside them as one suite, and
+# its tests are .spec.ts whatever the component is. Every other language is its
+# own family.
+_JS_FAMILY = frozenset({"javascript", "typescript", "tsx", "vue"})
+
+
+def _family_of(path: str) -> str | None:
+    """The language family a path's extension puts it in, or None for a file
+    no lizard reader parses (a .md, a .json, a .txt)."""
+    for language, extensions in LANGUAGE_EXTENSIONS.items():
+        if path.endswith(extensions):
+            return "javascript" if language in _JS_FAMILY else language
+    return None
+
+
 def _subject_stem(path: str) -> str | None:
     """The source stem a test file names, or None when the name is not a test.
     Four conventions cover every runner crapkit parses: foo.test.ts, foo.spec.ts,
-    test_foo.py, foo_test.py."""
+    test_foo.py, foo_test.py. The extension has to be one a reader parses:
+    docs/_mermaid_test.md is named like a test and is not one."""
     name = path.rsplit("/", 1)[-1]
     stem = _stem_of(path)
+    if _family_of(path) is None:
+        return None
     if ".test." in name or ".spec." in name:
         return stem
     if stem.startswith("test_"):
@@ -281,23 +301,53 @@ def _mirrored_parts(test_dir: str) -> tuple[str, ...]:
 def _mirrors(test_dir: str, source_dir: str) -> bool:
     """A tests/ mirror: the test directory, with its test-named components
     dropped, is a path suffix of the source directory. tests/api mirrors src/api;
-    a flat tests/ mirrors nothing, or it would claim the whole repo."""
+    a flat tests/ mirrors nothing, or it would claim the whole repo, and a
+    directory with no test-named component (a root src/) is no tests/ tree."""
     parts = _mirrored_parts(test_dir)
-    return parts == _path_parts(source_dir)[-len(parts):] if parts else False
+    if not parts or len(parts) == len(_path_parts(test_dir)):
+        return False
+    return parts == _path_parts(source_dir)[-len(parts):]
 
 
-def _test_files(tracked: list[str]) -> list[str]:
-    return sorted(p for p in tracked if _subject_stem(p))
+def _nearest_below(directory: str, candidates: tuple[str, ...]) -> str | None:
+    """The test below the directory with the fewest path components, then the
+    first alphabetically. The repo root has nothing below it: "below the root"
+    would be the whole repo."""
+    below = (p for p in candidates if _dir_of(p).startswith(directory + "/"))
+    return min(below, key=lambda p: (len(_path_parts(p)), p), default=None)
 
 
-def _matching_test(directory: str, stems: set, test_files: list[str]) -> str | None:
-    """The first tracked test file that names this directory's code: a same-stem
-    test anywhere in the repo (tests/test_parser.py for core/parser.py),
-    a sibling, or a tests/ mirror of the directory."""
-    for path in test_files:
-        if _subject_stem(path) in stems or _mirrors(_dir_of(path), directory):
-            return path
-    return None
+def _tests_by_family(tracked: list[str]) -> dict[str, tuple[str, ...]]:
+    """The tracked test files, sorted, under the language family each is in."""
+    by_family: dict[str, list[str]] = {}
+    for path in sorted(p for p in tracked if _subject_stem(p)):
+        by_family.setdefault(_family_of(path), []).append(path)
+    return {family: tuple(paths) for family, paths in by_family.items()}
+
+
+def _first(paths: tuple[str, ...], qualifies) -> str | None:
+    return next((p for p in paths if qualifies(p)), None)
+
+
+def _matching_test(directory: str, stems: set, families: set,
+                   tests: dict[str, tuple[str, ...]]) -> str | None:
+    """The tracked test file that names this directory's code, the nearest first:
+    a test in the directory, then the nearest one below it, then a tests/ mirror
+    of the directory, then a same-stem test anywhere (tests/test_parser.py for
+    core/parser.py).
+
+    Every tier only looks at tests in `families`, the language families of
+    the files the store scored here. The directory's other files do not count: a Python
+    directory with a static/ folder of .js below it is still Python, and on a
+    repo with twenty handler.test.ts files a stem alone paired a Python
+    directory with a TypeScript test.
+    """
+    candidates = tuple(sorted(p for family in families for p in tests.get(family, ())))
+    tiers = (lambda: _first(candidates, lambda p: _dir_of(p) == directory),
+             lambda: _nearest_below(directory, candidates),
+             lambda: _first(candidates, lambda p: _mirrors(_dir_of(p), directory)),
+             lambda: _first(candidates, lambda p: _subject_stem(p) in stems))
+    return next(filter(None, (tier() for tier in tiers)), None)
 
 
 def _group_dirs(rows, skip_scopes: frozenset[str]) -> dict[str, _DirStats]:
@@ -309,6 +359,7 @@ def _group_dirs(rows, skip_scopes: frozenset[str]) -> dict[str, _DirStats]:
         entry.functions += 1
         entry.flags.add(row.flag)
         entry.stems.add(_stem_of(row.path))
+        entry.families.add(_family_of(row.path))
     return stats
 
 
@@ -321,10 +372,10 @@ def unmeasured_directories(rows, tracked: list[str], *,
     tests pass, and the lane's own include list never looks at this code. One
     measured function anywhere in the directory clears it.
     """
-    test_files = _test_files(tracked)
+    test_files = _tests_by_family(tracked)
     found = []
     for directory, stats in sorted(_group_dirs(rows, skip_scopes).items()):
-        example = _matching_test(directory, stats.stems, test_files) \
+        example = _matching_test(directory, stats.stems, stats.families, test_files) \
             if stats.flags == {"untested"} else None
         if example:
             found.append(UnmeasuredDir(directory, stats.functions, example))

crapkit-0.7.4/src/crapkit/lizardpython.py

@@ -0,0 +1,262 @@
+"""A Python reader that reads a def's signature to its body colon. Upstream defect: crapkit #72.
+
+lizard 1.24.0's PythonReader ends a def inside its own signature in two shapes,
+and the def then reads as two lines at ccn 1 whatever its body holds, so it
+passes the complexity ceiling, the commit hook, `rescore --gate` and `verify`:
+
+    def f(value: int) -> tuple[        def make(cls_name, *, bases=(),
+        int, int                                slots=False):
+    ]:                                     if slots: ...
+        if value > 0: ...
+
+The left one is a return annotation opened on the def line. The right one is a
+line break after a parameter default that holds brackets, which is what black
+and ruff write for a long signature. Measured before the fix: 39 such defs in
+the 3,742 stdlib and site-packages files of crapkit's own Python 3.11
+environment, and 20 in 3,130 openclaw files.
+
+Three mechanics combine, all in lizard_languages/python.py:
+
+  1. `PythonStates._dec` takes the first `)` token for the end of the parameter
+     list, so the `)` of a default like `()` ends it early.
+  2. `PythonStates._state_colon` follows `:` into the body and sends anything
+     else, `->` included, to `_state_global`: the reader never follows a return
+     annotation to its colon.
+  3. `PythonReader.preprocess` sets nesting from each line's indent once the
+     def's long name ends with `)`. A signature line indented deeper than the
+     body pushes the def's nesting level there, the body's first line pops it,
+     and the pop ends the def before its body.
+
+The fix, and what it keeps
+--------------------------
+`PythonSignatureStates` counts bracket depth from the def's `(` and leaves the
+signature only at a `:` at depth 0, after the parameter list and after any
+return annotation. `PythonSignatureReader.preprocess` sets no nesting while the
+states are inside a signature, so the body's first line is the one that pushes
+the def. A body on the colon line (`) -> None: ...`) is the one exception,
+kept as lizard reads it: see `_SignatureIndents`.
+
+Every token still reaches the long name and the parameter list exactly as
+lizard routes it. lizard stops both at the signature's first `)` whatever its
+depth, and a def of that shape that lizard already read whole carries that
+spelling as its ratchet key, so this reader keeps it: `make( cls_name , * ,
+bases = ( )` above. The states also end where lizard ends for the same
+signature written on one line: `_state_first_line` after `):`, `_state_global`
+after a return annotation or after a signature lizard had closed early.
+
+What moves, only around a def lizard cut off: its end line, ccn, nloc, token
+count and cognitive score now cover its body, while its long name stays; an
+enclosing def gives back the conditions lizard had charged to it from the
+nested body; a def nested inside the cut-off def gains its parent's name as a
+prefix, as it has under a parent read whole.
+
+The class name
+--------------
+lizardcognitive picks its Python rules by `type(reader).__name__` starting with
+"python". A name like `CorrectedPythonReader` would score every Python file
+with the brace rules.
+
+Registration
+------------
+The same mechanism as crapkit.lizardrust, whose docstring explains it:
+`register()` rebinds `lizard_languages.PythonReader`, which
+`lizard_languages.languages()` reads on every call, verifies the rebind through
+`lizard.get_reader_for`, and raises if it did not take. analyze.py calls it at
+module scope beside the other readers' registrations, so pool workers register
+too.
+
+Retirement
+----------
+tests/unit/test_lizardpython.py::test_stock_reader_still_cuts_the_issue_def_off
+pins the stock reader's wrong answer. It fails on the lizard release that reads
+these signatures. Delete this module then, with the `register()` call.
+"""
+from __future__ import annotations
+
+from ._pygdefer import deferred_pygments
+
+with deferred_pygments():  # lizard's Erlang reader would load pygments here
+    import lizard
+    import lizard_languages
+    from lizard_languages.python import PythonIndents, PythonStates, count_spaces
+    from lizard_languages.python import PythonReader as _StockPythonReader
+
+_OPENERS = frozenset("([{")
+_CLOSERS = frozenset(")]}")
+
+# The states between the `def` keyword and the body colon. `_state_colon` is
+# the one lizard enters after the parameter list's `)`.
+_SIGNATURE_STATES = frozenset({
+    "_function", "_dec", "_state_parameterized_type_annotation", "_state_colon", "_rest_of_signature",
+})
+
+# Any filename picks the reader; the file is never opened.
+_PROBE = "crapkit_registration_probe.py"
+
+
+def _is_continuation(token: str) -> bool:
+    """A backslash line continuation, which lizard's tokenizer keeps as one token."""
+    return token.startswith("\\") and not token[1:].strip()
+
+
+def _depth_change(token: str) -> int:
+    if token in _OPENERS:
+        return 1
+    if token in _CLOSERS:
+        return -1
+    return 0
+
+
+class PythonSignatureStates(PythonStates):
+    """lizard's PythonStates, reading a signature to the colon at bracket depth 0.
+
+    `depth` counts the brackets open since the def's own `(`. The inherited
+    states keep every decision about the long name and the parameter list;
+    these overrides only choose where a state goes next.
+    """
+
+    def __init__(self, context, reader):
+        super().__init__(context, reader)
+        self.depth = 0
+
+    @property
+    def in_signature(self) -> bool:
+        """True from the `def` keyword until the body colon has been read."""
+        return self._state.__name__ in _SIGNATURE_STATES
+
+    def _function(self, token):
+        if token == "(":
+            self.depth = 1
+        super()._function(token)
+
+    def _dec(self, token):
+        if token == ")" and self.depth > 1:
+            # lizard's parameter list ends here too, spelled the same way; the
+            # signature does not.
+            self.depth -= 1
+            self.context.add_to_long_function_name(" )")
+            self._state = self._rest_of_signature
+            return
+        self.depth += _depth_change(token)
+        super()._dec(token)
+
+    def _state_parameterized_type_annotation(self, token):
+        self.depth += _depth_change(token)
+        super()._state_parameterized_type_annotation(token)
+
+    def _state_colon(self, token):
+        if token == "->":
+            self._state = self._rest_of_signature
+            return
+        if _is_continuation(token):  # `) \` then `-> ...:` on the next line
+            return
+        super()._state_colon(token)
+
+    def _rest_of_signature(self, token):
+        """The tokens lizard sent to `_state_global` before the body: counted, not named."""
+        if token == ":" and self.depth == 0:
+            self._state = self._state_global
+            return
+        self.depth += _depth_change(token)
+
+
+class _SignatureIndents(PythonIndents):
+    """lizard's per-line indent bookkeeping, holding back what a signature line sets.
+
+    lizard sets nesting from every line's first code token once the def's long
+    name ends with `)`. Inside a signature that is the defect: see mechanic 3.
+    The first level lizard would push from inside the signature is held, and
+    what happens to it depends on where the body starts:
+
+      * on the next line: dropped, and the body's first line pushes the def
+      * on the colon line (`) -> None: ...`): pushed at the body's first token,
+        so the def ends where lizard ends it, at the next line indented no
+        deeper. lizard lists a def of that shape only when its signature pushed
+        a level, and lists no def written `def f(x): return x` at all; this
+        keeps both answers.
+    """
+
+    def __init__(self, context, states):
+        super().__init__(context)
+        self.states = states
+        self.spaces = 0
+        self.leading = True
+        self.held = None
+
+    def see(self, token: str) -> None:
+        if token == "\n":
+            self._line_ends()
+        elif self.leading:
+            self._leading(token)
+        elif self.held is not None:
+            self._after_signature(token)
+
+    def _line_ends(self) -> None:
+        self.spaces, self.leading = 0, True
+        if not self.states.in_signature:
+            self.held = None
+
+    def _leading(self, token: str) -> None:
+        if token.isspace():
+            self.spaces += count_spaces(token)
+            return
+        self.leading = False
+        if token.startswith("#"):
+            return
+        if self.states.in_signature:
+            self._hold()
+        elif self._lizard_sets_nesting():
+            self.set_nesting(self.spaces, token)
+
+    def _hold(self) -> None:
+        if self.held is None and self._lizard_sets_nesting() and self.spaces > self.indents[-1]:
+            self.held = self.spaces
+
+    def _after_signature(self, token: str) -> None:
+        if self.states.in_signature or token.isspace() or token.startswith("#"):
+            return
+        self.set_nesting(self.held, token)
+        self.held = None
+
+    def _lizard_sets_nesting(self) -> bool:
+        function = self.context.current_function
+        return function.name == "*global*" or function.long_name.endswith(")")
+
+
+class PythonSignatureReader(_StockPythonReader):
+    """lizard's PythonReader with a def's signature read to its body colon (#72)."""
+
+    def __init__(self, context):
+        super().__init__(context)
+        self.parallel_states = [PythonSignatureStates(context, self)]
+
+    def preprocess(self, tokens):
+        """lizard's preprocess, with the indent rules of `_SignatureIndents`."""
+        indents = _SignatureIndents(self.context, self.parallel_states[0])
+        for token in self._soft_keyword_lookahead(tokens):
+            indents.see(token)
+            if not token.isspace() or token == "\n":
+                yield token
+        indents.reset()
+
+
+def register() -> None:
+    """Make lizard resolve `.py` to PythonSignatureReader. Idempotent.
+
+    Raises RuntimeError when the rebind does not reach lizard's own resolution.
+    A Python file measured with the defective reader is worse than a crash: the
+    score is wrong and looks fine.
+    """
+    lizard_languages.PythonReader = PythonSignatureReader
+    resolved = lizard.get_reader_for(_PROBE)
+    if resolved is not PythonSignatureReader:
+        raise RuntimeError(_unregistered(resolved))
+
+
+def _unregistered(resolved: type | None) -> str:
+    name = getattr(resolved, "__name__", "no reader")
+    return (f"crapkit.lizardpython.register() did not take: lizard resolves '.py' to "
+            f"{name}, not PythonSignatureReader. lizard {lizard.version} picks readers "
+            f"some other way than lizard_languages.languages(); rewrite register() "
+            f"against the new mechanism, or drop this module if lizard reads these "
+            f"signatures itself.")

{crapkit-0.7.3 → crapkit-0.7.4}/src/crapkit/procs.py

@@ -22,6 +22,8 @@ import tempfile
 import time
 from typing import IO
 
+from .errors import ToolError
+
 _OWN_GROUP = ({"creationflags": subprocess.CREATE_NEW_PROCESS_GROUP}
               if os.name == "nt" else {"start_new_session": True})
 
@@ -177,7 +179,10 @@ class _ProcessOwner:
 
     def start(self, process, family=None):
         """Register and release one launcher atomically against cancellation."""
-        self.register_then(process.pid, lambda: _release_launcher(process), family=family)
+        try:
+            self.register_then(process.pid, lambda: _release_launcher(process), family=family)
+        except OSError as error:
+            raise _dead_launcher(process, error) from error
 
     def register_then(self, pid, release, *, family=None):
         """Register a gated process, then release it before cancellation can enter."""
@@ -271,11 +276,49 @@ def _close_input(process) -> None:
         pass
 
 
+# How long a launcher whose input pipe is already dead gets to settle its exit
+# code before the message has to say it is still running.
+_LAUNCHER_SETTLE = 2.0
+
+# The code a Windows process exits with when a DLL's initialisation fails,
+# 0xC0000142. Seen at spawn on a loaded machine, before Python reads stdin.
+_DLL_INIT_FAILED = 3221225794
+
+
+class _LauncherDied(ToolError, OSError):
+    """A ToolError to the lane layer, which fails and retries that one lane.
+    Still an OSError to the doctor and init probes, which read an OSError from
+    run_bounded as a question that could not be put and answer with a finding."""
+
+
 def _release_launcher(process):
     process.stdin.write(b"go\n")
     process.stdin.flush()
 
 
+def _dead_launcher(process, error: OSError):
+    """The launcher exited before its start gate: registration or the start
+    line failed at the OS level. Windows Job assignment refuses an exited
+    process with access denied; the start line hits EINVAL there, EPIPE on
+    POSIX. Either is one lane's failure, which the lane layer retries, not a
+    crash of the whole run.
+    """
+    try:
+        code = process.wait(timeout=_LAUNCHER_SETTLE)
+    except subprocess.TimeoutExpired:
+        code = None
+    return _LauncherDied(f"command launcher {_launcher_fate(code, error)}, so the command never ran")
+
+
+def _launcher_fate(code, error: OSError) -> str:
+    if code is None:
+        return (f"was still running {_LAUNCHER_SETTLE:g}s after its start gate failed "
+                f"({error})")
+    if code == _DLL_INIT_FAILED:
+        return f"exited with code {code} (0xC0000142, STATUS_DLL_INIT_FAILED) before its start gate"
+    return f"exited with code {code} before its start gate"
+
+
 _OWNED_LAUNCH = """import json, os, sys
 if sys.stdin.buffer.readline() != b'go\\n':
     raise SystemExit(1)

{crapkit-0.7.3 → crapkit-0.7.4}/src/crapkit/retention.py

@@ -3,6 +3,7 @@ from contextlib import contextmanager
 import hashlib
 import json
 import math
+import os
 from pathlib import Path
 import shutil
 import tempfile
@@ -18,9 +19,26 @@ DEFAULT_TEST_RETENTION_COUNT = 10
 _RECEIPT = ".crapkit-test-run.json"
 
 
+def _same_place(path: Path, resolved: Path) -> bool:
+    r"""Whether `resolve()` named the directory `path` already names.
+
+    On Windows it names the same directory two other ways while a sibling
+    process is creating or deleting it: the extended-length form with the
+    `\\?\` prefix, and the NTFS tombstone under `$Extend\$Deleted` for a
+    directory whose last handle is still open. Two direct runners sharing a
+    repository hit both, and the guard read each as a redirect and refused.
+    A symlink or junction elsewhere still resolves elsewhere, and is still
+    refused.
+    """
+    text = str(resolved)
+    if text.startswith("\\\\?\\"):
+        text = text[4:]
+    return os.path.normcase(text) == os.path.normcase(str(path)) or "$Extend" in text
+
+
 def _parent(root: Path) -> Path:
     path = root / ".crapkit" / "test-runs"
-    if path.resolve() != path:
+    if not _same_place(path, path.resolve()):
         raise ToolError("test evidence retention refuses a redirected .crapkit/test-runs path")
     return path
 
@@ -30,7 +48,7 @@ def _lease(parent: Path, name: str) -> Path:
 
 
 def _safe_run(path: Path, parent: Path) -> bool:
-    return path.parent == parent and path.name.startswith("run-") and path.resolve() == path
+    return path.parent == parent and path.name.startswith("run-") and _same_place(path, path.resolve())
 
 
 def _valid_receipt(value: dict, root: Path, path: Path) -> bool:

{crapkit-0.7.3 → crapkit-0.7.4/src/crapkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crapkit
-Version: 0.7.3
+Version: 0.7.4
 Summary: Scores every function on complexity times uncovered risk, ranks the worst, and blocks commits that add more.
 Author: Jean-Francois Gagne
 License: MIT
@@ -199,7 +199,7 @@ files. Review those commands before running Crapkit in a repository you do not t
 
 ```
 $ crapkit --version
-crapkit 0.7.3
+crapkit 0.7.4
 ```
 
 `python -m crapkit` works identically to the console script and is what to use from a
@@ -455,7 +455,7 @@ crapkit ships a `.pre-commit-hooks.yaml` declaring `id: crapkit-gate`. In your
 repos:
   - repo: https://github.com/JeanFrancoisGagne/crapkit
     # crapkit's release step rewrites this line to the tag it just cut
-    rev: v0.7.3
+    rev: v0.7.4
     hooks:
       - id: crapkit-gate
 ```
@@ -563,7 +563,7 @@ to a workflow, and every input has a default:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - uses: JeanFrancoisGagne/crapkit@v0.7.3
+      - uses: JeanFrancoisGagne/crapkit@v0.7.4
 ```
 
 The whole job those four lines sit in:
@@ -583,7 +583,7 @@ jobs:
         with:
           python-version: "3.12"       # the interpreter the install below lands in
       - run: pip install -e ".[dev]"   # whatever your lanes need to run
-      - uses: JeanFrancoisGagne/crapkit@v0.7.3
+      - uses: JeanFrancoisGagne/crapkit@v0.7.4
         with:
           gate: "false"
 ```

{crapkit-0.7.3 → crapkit-0.7.4}/src/crapkit.egg-info/SOURCES.txt

@@ -35,6 +35,7 @@ src/crapkit/keys.py
 src/crapkit/lanes.py
 src/crapkit/lizardcognitive.py
 src/crapkit/lizardpowershell.py
+src/crapkit/lizardpython.py
 src/crapkit/lizardrust.py
 src/crapkit/lizardshell.py
 src/crapkit/lizardtypescript.py