crapkit 0.7.2__tar.gz → 0.7.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crapkit
-Version: 0.7.2
+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.2
+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.2
+    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.2
+      - 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.2
+      - uses: JeanFrancoisGagne/crapkit@v0.7.4
         with:
           gate: "false"
 ```

{crapkit-0.7.2 → 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.2
+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.2
+    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.2
+      - 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.2
+      - uses: JeanFrancoisGagne/crapkit@v0.7.4
         with:
           gate: "false"
 ```

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "crapkit"
-version = "0.7.2"
+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.2 → crapkit-0.7.4}/src/crapkit/__init__.py

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

{crapkit-0.7.2 → 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.2 → 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.2 → crapkit-0.7.4}/src/crapkit/cli/scoring.py

@@ -540,12 +540,25 @@ def _rescored_records(root: Path, cache_path: Path, flat: list,
     return records_by_path
 
 
+def _refuse_missing(root: Path, rel_paths: list) -> None:
+    """A path crapkit cannot open is refused the way one it cannot place is.
+
+    Unchecked, a typo reached the analyzer and came back as a FileNotFoundError
+    traceback with exit 1; through the MCP server that traceback was the whole
+    answer. A config error says which path, and exits 3 like every other
+    argument the command cannot act on."""
+    missing = [rel for rel in rel_paths if not (root / rel).exists()]
+    if missing:
+        raise ConfigError(f"{', '.join(missing)} does not exist under {root}")
+
+
 def _rescore_analyze(root: Path, cfg, files, cwd: Path | None = None) -> tuple[list, list, dict]:
     """Fresh complexity for the named files, said from `cwd` where the user
     stands; the shared cache is merged, never truncated."""
     from ..hook import file_ceilings
 
     rel_paths = sorted({_repo_relative(p, root, cwd) for p in files})
+    _refuse_missing(root, rel_paths)
     files_by_scope = assign_files(rel_paths, cfg, size_of=_file_sizer(root))
     flat = sorted(set().union(*files_by_scope.values())) if files_by_scope else []
     records_by_path = _rescored_records(root, root / ".crapkit" / "cache.json", flat,

{crapkit-0.7.2 → crapkit-0.7.4}/src/crapkit/cli/verifying.py

@@ -558,6 +558,20 @@ def _ratchet_suffix(changes: dict | None, overridden: list, ratchet_file: str) -
     return f" ratchet: {_marks_moved(changes)} -> git add {ratchet_file}"
 
 
+def _forgiven_suffix(out: dict) -> str:
+    """Failures this verdict forgives because the baseline carries them too.
+
+    A regression verdict is about change, so an unchanged failure is not a
+    regression. Saying nothing about it made `verify OK` read as a clean suite
+    beside three failing tests, and the release guard downstream, which does not
+    forgive them, then refused evidence the operator had just watched pass."""
+    forgiven = out.get("forgiven_failures") or ()
+    if not forgiven:
+        return ""
+    plural = "" if len(forgiven) == 1 else "s"
+    return f" ({len(forgiven)} unchanged failure{plural} forgiven, first {forgiven[0]})"
+
+
 def _report_verify(as_json: bool, out: dict, verdict, overridden, ratchet_file: str) -> None:
     if as_json:
         _print_json(out)
@@ -565,6 +579,7 @@ def _report_verify(as_json: bool, out: dict, verdict, overridden, ratchet_file:
     state = "OK" if verdict.ok else "FAILED"
     print(f"verify {state} @ {out['commit'][:11]} vs baseline {out['baseline_commit'][:11]} "
           f"({out['changed_files']} changed files)"
+          f"{_forgiven_suffix(out)}"
           f"{_ratchet_suffix(out['ratchet_changes'], overridden, ratchet_file)}")
     _print_verify_findings(verdict, overridden)
     _print_finding_split(verdict)
@@ -649,7 +664,8 @@ def cmd_verify(args: argparse.Namespace) -> int:
     _report_verify(args.json,
                    {**_verify_result(verdict, overridden, run_id, baseline, commit, ranges,
                                      uncovered, cfg.diff_uncovered_max, len(unmarked)),
-                    **_receipt(tool_versions, saved.sha256, changes)},
+                    **_receipt(tool_versions, saved.sha256, changes),
+                    "forgiven_failures": sorted(set(fresh_failures) - set(verdict.new_failures))},
                    verdict, overridden, cfg.ratchet_file)
     _refuse_override(verdict, args.override)
     return _verify_exit_code(verdict)

{crapkit-0.7.2 → 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))