Files
claude-config/bin/repo_checks/test_package_cycles.py
T

145 lines
7.1 KiB
Python

import ast
import graphlib
import pathlib
import sys
import tempfile
import unittest
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
from repo_checks import ROOT
def imported_by(module: pathlib.Path) -> set[str]:
"""The top-level name of each module that the file module imports. A deferred import inside a function counts: it only hides a cycle."""
found: set[str] = set()
for node in ast.walk(ast.parse(module.read_text(encoding="utf-8"))):
names = [alias.name for alias in node.names] if isinstance(node, ast.Import) else [node.module or ""] if isinstance(node, ast.ImportFrom) and node.level == 0 else []
found.update(name.split(".")[0] for name in names)
return found
def package_imports(bin_folder: pathlib.Path) -> dict[str, set[str]]:
"""Each package under bin_folder, with the other packages its modules import, tests aside."""
packages = {init.parent.name for init in bin_folder.glob("*/__init__.py")}
imported: dict[str, set[str]] = {package: set() for package in packages}
for package in packages:
for module in (bin_folder / package).rglob("*.py"):
if module.name.startswith("test_"):
continue
imported[package].update(top for top in imported_by(module) if top in packages and top != package)
return imported
# The entry points that drive chunks. What two of them need lives in bin/chunk_driver/, so no other package imports one, its tests included.
DRIVERS = ("do_epic", "loop_claude")
def driver_imports(bin_folder: pathlib.Path, drivers: tuple[str, ...]) -> list[str]:
"""Each module under bin_folder that imports a driver's package from outside it, tests included, as `<module> imports <driver>`."""
found = []
for module in sorted(bin_folder.rglob("*.py")):
package = module.relative_to(bin_folder).parts[0]
found += [f"{module.relative_to(bin_folder)} imports {top}" for top in imported_by(module) if top in drivers and top != package]
return sorted(found)
# The packages a package may not import, its tests included, since they are the layer above it: chunk_driver drives chunks through agent_cycle.
ABOVE = {"agent_cycle": ("chunk_driver",)}
def upward_imports(bin_folder: pathlib.Path, above: dict[str, tuple[str, ...]]) -> list[str]:
"""Each module under bin_folder that imports a package above names as above its own, tests included, as `<module> imports <package>`."""
found = []
for package, banned in above.items():
for module in sorted((bin_folder / package).rglob("*.py")):
found += [f"{module.relative_to(bin_folder)} imports {top}" for top in imported_by(module) if top in banned]
return sorted(found)
def imports_of_test_modules(bin_folder: pathlib.Path) -> list[str]:
"""Each module under bin_folder that imports a test module of another package, as `<module> imports <test module>`. A module at bin_folder's root, such as test_env.py, belongs to no package."""
found = []
for module in sorted(bin_folder.rglob("*.py")):
package = module.relative_to(bin_folder).parts[0]
for node in ast.walk(ast.parse(module.read_text(encoding="utf-8"))):
names = [alias.name for alias in node.names] if isinstance(node, ast.Import) else [f"{node.module}.{alias.name}" for alias in node.names] if isinstance(node, ast.ImportFrom) and node.level == 0 and node.module else []
for name in names:
top, *below = name.split(".")
tests = [part for part in below if part.startswith("test_")]
if tests and top != package:
found.append(f"{module.relative_to(bin_folder)} imports {name[:name.index(tests[0]) + len(tests[0])]}")
return sorted(set(found))
def cycle(imported: dict[str, set[str]]) -> list[str]:
"""One cycle among the packages, as the packages along it; empty where there is none."""
try:
graphlib.TopologicalSorter(imported).prepare()
except graphlib.CycleError as found:
return list(found.args[1])
return []
def tree(folder: pathlib.Path, sources: dict[str, str]) -> None:
"""Writes each source to its path under folder."""
for path, source in sources.items():
(folder / path).parent.mkdir(parents=True, exist_ok=True)
(folder / path).write_text(source, encoding="utf-8")
class PackageCycles(unittest.TestCase):
def test_no_package_under_bin_imports_one_that_imports_it_back(self):
self.assertEqual(cycle(package_imports(ROOT / "bin")), [], "move what both packages need into a package that imports neither")
def test_no_package_imports_a_driver_of_chunks(self):
self.assertEqual(driver_imports(ROOT / "bin", DRIVERS), [], "move what the importer needs into bin/chunk_driver/, or a test double into the package whose code it stands in for")
def test_no_package_imports_the_layer_above_it(self):
self.assertEqual(upward_imports(ROOT / "bin", ABOVE), [], "pass the value in from the layer above, or in a test write it as a literal")
def test_an_import_of_the_layer_above_is_found_in_tests_too(self):
with tempfile.TemporaryDirectory() as temp:
folder = pathlib.Path(temp)
tree(folder, {"low/mod.py": "import other\n", "low/test_mod.py": "from high.mod import x\n", "low/run.py": "def f():\n\timport high\n", "high/mod.py": "import low\n"})
self.assertEqual(upward_imports(folder, {"low": ("high",)}), ["low/run.py imports high", "low/test_mod.py imports high"])
def test_a_driver_imported_from_another_package_is_found_in_tests_too(self):
with tempfile.TemporaryDirectory() as temp:
folder = pathlib.Path(temp)
tree(folder, {"a/mod.py": "import a.other\n", "b/test_mod.py": "from a.mod import x\n", "b/mod.py": "def f():\n\timport a\n", "c/mod.py": "import b\n"})
self.assertEqual(driver_imports(folder, ("a",)), ["b/mod.py imports a", "b/test_mod.py imports a"])
def test_no_module_imports_a_test_module_of_another_package(self):
self.assertEqual(imports_of_test_modules(ROOT / "bin"), [], "move what the importer needs into the doubles.py of the package that owns it")
def test_a_test_module_imported_from_another_package_is_found_however_it_is_spelled(self):
with tempfile.TemporaryDirectory() as temp:
folder = pathlib.Path(temp)
tree(folder, {
"a/test_mod.py": "from a.test_other import x\nfrom test_env import y\nfrom a.doubles import z\n",
"b/test_mod.py": "from a.test_mod import x\n",
"b/mod.py": "def f():\n\timport a.deep.test_far\n",
"c/test_mod.py": "from a import test_mod\nfrom a.test_mod import x, y\n",
"test_root.py": "from a.test_mod import x\n",
})
self.assertEqual(imports_of_test_modules(folder), ["b/mod.py imports a.deep.test_far", "b/test_mod.py imports a.test_mod", "c/test_mod.py imports a.test_mod", "test_root.py imports a.test_mod"])
def test_reads_an_import_deferred_into_a_function_and_leaves_out_tests(self):
with tempfile.TemporaryDirectory() as temp:
folder = pathlib.Path(temp)
tree(folder, {
"a/__init__.py": "", "a/mod.py": "def f():\n\tfrom b.mod import x\n",
"b/__init__.py": "", "b/mod.py": "import a.mod\n",
"c/__init__.py": "", "c/mod.py": "", "c/test_mod.py": "import a\n",
})
self.assertEqual(package_imports(folder), {"a": {"b"}, "b": {"a"}, "c": set()})
def test_a_cycle_through_a_deferred_import_is_found(self):
self.assertEqual(sorted(cycle({"a": {"b"}, "b": {"a"}})[:2]), ["a", "b"])
self.assertEqual(cycle({"a": {"b"}, "b": set()}), [])
if __name__ == "__main__":
unittest.main()