pytest-orm-boundaries 0.2.0__tar.gz → 0.3.1__tar.gz

{pytest_orm_boundaries-0.2.0 → pytest_orm_boundaries-0.3.1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: pytest-orm-boundaries
-Version: 0.2.0
-Summary: Pytest plugin that fails your tests when ORM queries cross DDD aggregate boundaries (Django supported today).
+Version: 0.3.1
+Summary: Pytest plugin that fails tests when ORM queries cross DDD aggregate boundaries (Django supported today).
 Keywords: django,pytest,plugin,orm,ddd,aggregate,boundaries,architecture
 Author: Evgeniia Chibisova
 License-Expression: MIT
@@ -28,7 +28,7 @@ Description-Content-Type: text/markdown
 
 > 💡 **Even if you control your imports — boundaries still can leak through the ORM**
 
-A `pytest-orm-boundaries` is a pytest plugin that fails your tests when ORM queries cross your DDD aggregate boundaries.
+A `pytest-orm-boundaries` is a pytest plugin that reports ORM queries crossing your DDD aggregate boundaries.
 
 Currently works with Django ORM.
 
@@ -68,6 +68,26 @@ purchase = ["bookshop.Purchase", "bookshop.PurchaseLine"]
 Models are written as `app_label.Model`. Models not listed in any aggregate are
 not checked. Without a config file the plugin emits a warning and runs no checks.
 
+## The report
+
+At the end of the run, the plugin prints one grouped entry per offending place:
+
+```
+===================== orm-boundaries: boundary violations ======================
+1 place(s) in your code crossed aggregate boundaries, affecting 1 test(s):
+
+bookshop/purchases.py:29
+    code: return list(Purchase.objects.filter(client__name=name))
+    crosses: client, purchase
+    affected tests (1):
+      test_purchases.py::test_get_purchases_by_client_name
+
+orm-boundaries: FAILED - 1 boundary violation(s), run exits non-zero.
+```
+
+The run exits non-zero when there are violations, so CI catches them.
+Pass `-v` to list all affected tests.
+
 ## Ignoring files
 
 Add exceptions so that known offenders keep passing while you fix them one file at a time:

{pytest_orm_boundaries-0.2.0 → pytest_orm_boundaries-0.3.1}/README.md

@@ -2,7 +2,7 @@
 
 > 💡 **Even if you control your imports — boundaries still can leak through the ORM**
 
-A `pytest-orm-boundaries` is a pytest plugin that fails your tests when ORM queries cross your DDD aggregate boundaries.
+A `pytest-orm-boundaries` is a pytest plugin that reports ORM queries crossing your DDD aggregate boundaries.
 
 Currently works with Django ORM.
 
@@ -42,6 +42,26 @@ purchase = ["bookshop.Purchase", "bookshop.PurchaseLine"]
 Models are written as `app_label.Model`. Models not listed in any aggregate are
 not checked. Without a config file the plugin emits a warning and runs no checks.
 
+## The report
+
+At the end of the run, the plugin prints one grouped entry per offending place:
+
+```
+===================== orm-boundaries: boundary violations ======================
+1 place(s) in your code crossed aggregate boundaries, affecting 1 test(s):
+
+bookshop/purchases.py:29
+    code: return list(Purchase.objects.filter(client__name=name))
+    crosses: client, purchase
+    affected tests (1):
+      test_purchases.py::test_get_purchases_by_client_name
+
+orm-boundaries: FAILED - 1 boundary violation(s), run exits non-zero.
+```
+
+The run exits non-zero when there are violations, so CI catches them.
+Pass `-v` to list all affected tests.
+
 ## Ignoring files
 
 Add exceptions so that known offenders keep passing while you fix them one file at a time:

{pytest_orm_boundaries-0.2.0 → pytest_orm_boundaries-0.3.1}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "uv_build"
 
 [project]
 name = "pytest-orm-boundaries"
-version = "0.2.0"
-description = "Pytest plugin that fails your tests when ORM queries cross DDD aggregate boundaries (Django supported today)."
+version = "0.3.1"
+description = "Pytest plugin that fails tests when ORM queries cross DDD aggregate boundaries (Django supported today)."
 readme = "README.md"
 requires-python = ">=3.11"
 license = "MIT"
@@ -46,3 +46,6 @@ boundaries = "pytest_orm_boundaries.plugin"
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+
+[dependency-groups]
+dev = ["django>=4.2"]

pytest_orm_boundaries-0.3.1/src/pytest_orm_boundaries/build_report.py

@@ -0,0 +1,102 @@
+"""Render orm-boundaries results to the pytest terminal."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pytest_orm_boundaries.read_config import CONFIG_FILE_NAME
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    import pytest
+
+    from pytest_orm_boundaries.guard import ViolationRecord
+
+MAX_TESTS_SHOWN = 5
+
+
+def report_violations(
+    *,
+    terminalreporter: pytest.TerminalReporter,
+    violations: list[ViolationRecord],
+    verbose: bool = False,
+) -> None:
+    """Print one grouped entry per offending call place: which aggregates the
+    query crossed, the models it joined, and which tests reached it.
+    """
+    if not violations:
+        return
+
+    affected = len({test for violation in violations for test in violation.tests})
+    terminalreporter.section(
+        "orm-boundaries: boundary violations", red=True, bold=True
+    )
+    terminalreporter.write_line(
+        f"{len(violations)} place(s) in your code crossed aggregate boundaries, "
+        f"affecting {affected} test(s):",
+        red=True,
+    )
+    for violation in violations:
+        _write_violation(
+            terminalreporter=terminalreporter, violation=violation, verbose=verbose
+        )
+    terminalreporter.write_line("")
+    terminalreporter.write_line(
+        f"orm-boundaries: FAILED - {len(violations)} boundary violation(s), "
+        "run exits non-zero.",
+        red=True,
+        bold=True,
+    )
+
+
+def _write_violation(
+    *,
+    terminalreporter: pytest.TerminalReporter,
+    violation: ViolationRecord,
+    verbose: bool,
+) -> None:
+    terminalreporter.write_line("")
+    terminalreporter.write_line(f"{violation.file}:{violation.line_number}", bold=True)
+    aggregates = " ↔ ".join(violation.crossed_aggregates)
+    terminalreporter.write_line(
+        f"    crossed aggregates: {aggregates}", yellow=True, bold=True
+    )
+    models = ", ".join(violation.joined_models)
+    terminalreporter.write_line(f"    models: {models}")
+
+    tests = sorted(violation.tests)
+    if not tests:
+        terminalreporter.write_line("    tests affected: (none captured)", light=True)
+        return
+
+    shown = tests if verbose else tests[:MAX_TESTS_SHOWN]
+    terminalreporter.write_line(f"    {len(tests)} test(s) affected:", light=True)
+    for nodeid in shown:
+        terminalreporter.write_line(f"      {nodeid}", light=True)
+    hidden = len(tests) - len(shown)
+    if hidden:
+        terminalreporter.write_line(
+            f"      ... +{hidden} more (-v to list all)", light=True
+        )
+
+
+def report_stale_ignores(
+    *, terminalreporter: pytest.TerminalReporter, stale: list[str]
+) -> None:
+    if not stale:
+        return
+    terminalreporter.section("orm-boundaries: stale ignores", yellow=True, bold=True)
+    terminalreporter.write_line(
+        "These [ignore] entries no longer suppress any boundary violation - "
+        f"their files are clean now. Remove them from {CONFIG_FILE_NAME}:",
+        yellow=True,
+    )
+    for pattern in stale:
+        terminalreporter.write_line(f"  - {pattern}", yellow=True)
+
+
+def render_header(*, config_path: Path | None) -> str:
+    if config_path is None:
+        return "orm-boundaries: no config file, checks disabled"
+    return f"orm-boundaries: config {config_path}"

pytest_orm_boundaries-0.3.1/src/pytest_orm_boundaries/call_stack.py

@@ -0,0 +1,38 @@
+"""Call-stack inspection: the in-project frames behind a query."""
+
+from __future__ import annotations
+
+import inspect
+from pathlib import Path
+
+# Installed deps live under these segments even when .venv is inside the project
+# root, so match the segment, not the (varying) venv dir name.
+_THIRD_PARTY_SEGMENTS = frozenset({"site-packages", "dist-packages"})
+
+
+def _is_third_party(*, relative: Path) -> bool:
+    """True if a root-relative path points into installed third-party code."""
+    return not _THIRD_PARTY_SEGMENTS.isdisjoint(relative.parts)
+
+
+def find_in_project_frames(*, root: Path) -> list[tuple[str, int]]:
+    """(root-relative path, line) for each in-project frame, innermost first.
+
+    Skips stdlib (outside root) and installed packages; frames[0] is the line
+    that issued the ORM call.
+    """
+    frames: list[tuple[str, int]] = []
+    frame = inspect.currentframe()
+    frame = frame.f_back if frame else None  # skip our own frame
+    while frame is not None:
+        filename = frame.f_code.co_filename
+        lineno = frame.f_lineno
+        frame = frame.f_back
+        try:
+            relative = Path(filename).relative_to(root)
+        except ValueError:
+            continue
+        if _is_third_party(relative=relative):
+            continue
+        frames.append((relative.as_posix(), lineno))
+    return frames

pytest_orm_boundaries-0.3.1/src/pytest_orm_boundaries/guard.py

@@ -0,0 +1,197 @@
+"""Django boundary guard: the aggregate-crossing rule and the query
+interception that records crossings.
+"""
+
+from __future__ import annotations
+
+import functools
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from pytest_orm_boundaries.call_stack import find_in_project_frames
+from pytest_orm_boundaries.ignores import IgnoreTracker
+from pytest_orm_boundaries.read_config import (
+    load_aggregates_from_config,
+    load_ignored_files_from_config,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable
+    from typing import Any
+
+    from django.db.models import Model
+    from django.db.models.sql.query import Query
+
+
+@dataclass
+class ViolationRecord:
+    """One offending call place and the tests that reached it.
+
+    Grouped by call place so a crossing shared by many tests is one entry,
+    not one line per test.
+    """
+
+    file: str
+    line_number: int
+    crossed_aggregates: tuple[str, ...]  # ("order", "payment")
+    joined_models: tuple[str, ...]  # ("order.Invoice", "payrolls.IncomePayment")
+    tests: set[str] = field(default_factory=set)
+
+
+class BoundaryGuard:
+    """Intercepts Django's executed queries and records aggregate crossings."""
+
+    def __init__(
+        self,
+        *,
+        aggregates_config: dict[str, str],
+        ignore_tracker: IgnoreTracker,
+        root: Path,
+    ) -> None:
+        self._aggregates_config = aggregates_config
+        self._ignore_tracker = ignore_tracker
+        self._root = Path(root)
+        self._original_execute_sql: Callable[..., Any] | None = None
+        self._current_test: str | None = None
+        self._violations: dict[tuple[str, int, tuple[str, ...]], ViolationRecord] = {}
+
+    def install(self) -> None:
+        from django.db.models.sql.compiler import SQLCompiler
+
+        original_execute_sql = SQLCompiler.execute_sql
+        self._original_execute_sql = original_execute_sql
+
+        def patched_execute_sql(compiler, *args, **kwargs):
+            self._handle_query(query=compiler.query)
+            return original_execute_sql(compiler, *args, **kwargs)
+
+        SQLCompiler.execute_sql = patched_execute_sql
+
+    def uninstall(self) -> None:
+        from django.db.models.sql.compiler import SQLCompiler
+
+        SQLCompiler.execute_sql = self._original_execute_sql
+
+    def set_current_test(self, nodeid: str | None) -> None:
+        """Remember which test is running so a recorded crossing can name it."""
+        self._current_test = nodeid
+
+    @property
+    def violations(self) -> list[ViolationRecord]:
+        """Recorded crossings, most-affecting first (then by call place)."""
+        return sorted(
+            self._violations.values(),
+            key=lambda v: (-len(v.tests), v.file, v.line_number),
+        )
+
+    def find_stale_patterns(self) -> list[str]:
+        return self._ignore_tracker.find_stale_patterns()
+
+    def _handle_query(self, *, query: Query) -> None:
+        """Handle one executed query: gather stack context, apply the aggregate
+        rule, and record a crossing (unless it's clean or its place is ignored).
+        """
+        # ``frames`` is the in-project part of this query's call stack,
+        # used by the ignore/stale check and the report.
+        frames: list[tuple[str, int]] | None = None
+        file_paths: list[str] | None = None
+        if self._ignore_tracker.is_active:
+            frames = find_in_project_frames(root=self._root)
+            file_paths = self._extract_file_paths(frames)
+            self._ignore_tracker.mark_seen(file_paths=file_paths)
+
+        labels = self._read_labels(query=query)
+        crossing = self._find_crossing(labels=labels)
+        if crossing is None:
+            return
+
+        if file_paths is not None and self._ignore_tracker.has_ignore_for(
+            file_paths=file_paths
+        ):
+            self._ignore_tracker.mark_used(file_paths=file_paths)
+            return
+
+        if frames is None:
+            frames = find_in_project_frames(root=self._root)
+        self._record_violation(
+            call_place=frames[0] if frames else None, crossing=crossing
+        )
+
+    def _read_labels(self, *, query: Query) -> list[str]:
+        """Model labels of the tables the query actually reads.
+
+        A filter on a foreign-key id reads a column already on the current
+        table, so the table it points to isn't read -- and isn't counted.
+        """
+        table_to_model = _map_tables_to_models()
+        return [
+            table_to_model[table.table_name]._meta.label
+            for alias, table in query.alias_map.items()
+            if table.table_name in table_to_model
+            and query.alias_refcount.get(alias, 0) > 0
+        ]
+
+    def _find_crossing(
+        self, *, labels: Iterable[str]
+    ) -> tuple[tuple[str, ...], tuple[str, ...]] | None:
+        """Return ``(crossed aggregate names, joined model labels)`` if the query
+        crosses a boundary, else None.
+
+        e.g. ``(("order", "payment"), ("order.Invoice", "payrolls.IncomePayment"))``.
+        """
+        aggregate_by_label = {
+            label: aggregate
+            for label in labels
+            if (aggregate := self._aggregates_config.get(label.lower())) is not None
+        }
+        aggregates = set(aggregate_by_label.values())
+        if len(aggregates) <= 1:
+            return None
+        return tuple(sorted(aggregates)), tuple(sorted(aggregate_by_label.keys()))
+
+    def _record_violation(
+        self,
+        *,
+        call_place: tuple[str, int] | None,
+        crossing: tuple[tuple[str, ...], tuple[str, ...]],
+    ) -> None:
+        crossed_aggregates, joined_models = crossing
+        file, line = call_place if call_place is not None else ("<unknown>", 0)
+        key = (file, line, crossed_aggregates)
+        record = self._violations.get(key)
+        if record is None:
+            record = ViolationRecord(
+                file=file,
+                line_number=line,
+                crossed_aggregates=crossed_aggregates,
+                joined_models=joined_models,
+            )
+            self._violations[key] = record
+        if self._current_test is not None:
+            record.tests.add(self._current_test)
+
+    @staticmethod
+    def _extract_file_paths(frames: Iterable[tuple[str, int]]) -> set[str]:
+        return {path for path, _ in frames}
+
+
+def build_guard(*, rootpath: Path, config_path: Path) -> BoundaryGuard | None:
+    aggregates_by_model = load_aggregates_from_config(path=config_path)
+    if not aggregates_by_model:
+        return None
+
+    ignore_patterns = load_ignored_files_from_config(path=config_path)
+    tracker = IgnoreTracker(patterns=ignore_patterns)
+
+    return BoundaryGuard(
+        aggregates_config=aggregates_by_model, ignore_tracker=tracker, root=rootpath
+    )
+
+
+@functools.cache
+def _map_tables_to_models() -> dict[str, type[Model]]:
+    """Map db_table -> model class for every installed model."""
+    from django.apps import apps
+
+    return {model._meta.db_table: model for model in apps.get_models()}

{pytest_orm_boundaries-0.2.0 → pytest_orm_boundaries-0.3.1}/src/pytest_orm_boundaries/ignores.py

@@ -1,19 +1,16 @@
-"""Per-file ignores at runtime: the tracker and call-stack inspection."""
+"""Per-file ignores at runtime: the IgnoreTracker book-keeping."""
 
 from __future__ import annotations
 
-import inspect
 from collections.abc import Iterable
 from fnmatch import fnmatch
-from pathlib import Path
 
 
 class IgnoreTracker:
     """Decides whether a violation is ignored, and reports ignore globs that went
     stale - their file ran but never crossed a boundary."""
 
-    def __init__(self, *, patterns: Iterable[str], root: Path) -> None:
-        self.root = Path(root)
+    def __init__(self, *, patterns: Iterable[str]) -> None:
         self._patterns = list(dict.fromkeys(patterns))  # ordered, de-duped
         self._seen: set[str] = set()  # patterns executed during the run
         self._used: set[str] = set()  # ...that also crossed a boundary
@@ -24,7 +21,7 @@ class IgnoreTracker:
 
     def mark_seen(self, *, file_paths: Iterable[str]) -> None:
         self._seen.update(self._find_matching_patterns(file_paths))
-    
+
     def mark_used(self, *, file_paths: Iterable[str]) -> None:
         self._used.update(self._find_matching_patterns(file_paths))
 
@@ -36,26 +33,3 @@ class IgnoreTracker:
 
     def _find_matching_patterns(self, file_paths: Iterable[str]) -> set[str]:
         return {p for f in file_paths for p in self._patterns if fnmatch(f, p)}
-
-
-def find_source_files_in_stack(*, root: Path) -> list[str]:
-    """Root-relative (posix) paths of project files on the current call stack.
-
-    Frames outside ``root`` (Django, pytest, stdlib) are skipped, leaving the
-    application/test files that led to this query.
-    """
-    files: list[str] = []
-    seen: set[str] = set()
-    frame = inspect.currentframe()
-    frame = frame.f_back if frame else None  # start at the caller, skip our own frame
-    while frame is not None:
-        filename = frame.f_code.co_filename
-        frame = frame.f_back  # for next iteration
-        if filename in seen:
-            continue
-        seen.add(filename)
-        try:
-            files.append(Path(filename).relative_to(root).as_posix())
-        except ValueError:
-            continue
-    return files

{pytest_orm_boundaries-0.2.0 → pytest_orm_boundaries-0.3.1}/src/pytest_orm_boundaries/plugin.py

@@ -19,13 +19,18 @@ if TYPE_CHECKING:
     from pytest_orm_boundaries.guard import BoundaryGuard
 
 config_path_key = pytest.StashKey[Path | None]()
-guard_key = pytest.StashKey["BoundaryGuard | None"]()
+guard_key = pytest.StashKey["BoundaryGuard"]()
 
 
 class BoundariesConfigWarning(UserWarning):
     """Plugin is installed but no config file was found."""
 
 
+def _installed_guard(config: pytest.Config) -> BoundaryGuard | None:
+    """The guard for this run, or None if no config or aggregates were found."""
+    return config.stash.get(guard_key, None)
+
+
 def pytest_addoption(parser: pytest.Parser) -> None:
     group = parser.getgroup("orm-boundaries")
     group.addoption(
@@ -47,11 +52,8 @@ def pytest_addoption(parser: pytest.Parser) -> None:
 
 
 def pytest_configure(config: pytest.Config) -> None:
-    """Resolve the config and install the guard, stashing what other hooks need:
-
-    - ``config_path_key`` -- to show where the config came from in the report.
-    - ``guard_key`` -- to restore the patched query method on teardown and to
-      report stale ignores at the end of the run.
+    """Resolve config and install the guard, stashing both for later hooks:
+    the config path for the report header, the guard for teardown and reporting.
     """
     explicit_config = config.getoption("boundaries_config") or config.getini("boundaries_config")
     try:
@@ -73,9 +75,29 @@ def pytest_configure(config: pytest.Config) -> None:
 
 
 def pytest_unconfigure(config: pytest.Config) -> None:
-    guard = config.stash.get(guard_key, None)
+    guard = _installed_guard(config)
     if guard is not None:
-        guard.restore_original_runner()
+        guard.uninstall()
+
+
+@pytest.hookimpl(wrapper=True)
+def pytest_runtest_protocol(item: pytest.Item, nextitem: pytest.Item | None):
+    """Tell the guard which test is running so a violation can name it."""
+    guard = _installed_guard(item.config)
+    if guard is not None:
+        guard.set_current_test(item.nodeid)
+    try:
+        return (yield)
+    finally:
+        if guard is not None:
+            guard.set_current_test(None)
+
+
+def pytest_sessionfinish(session: pytest.Session, exitstatus: int) -> None:
+    """A clean-but-violating run must still fail the run (via the exit code)."""
+    guard = _installed_guard(session.config)
+    if guard is not None and guard.violations and exitstatus == pytest.ExitCode.OK:
+        session.exitstatus = pytest.ExitCode.TESTS_FAILED
 
 
 def pytest_terminal_summary(
@@ -83,14 +105,18 @@ def pytest_terminal_summary(
     exitstatus: int,
     config: pytest.Config,
 ) -> None:
-    guard = config.stash.get(guard_key, None)
-    if guard is not None:
-        stale = guard.find_stale_patterns()
-        build_report.report_stale_ignores(
-            terminalreporter=terminalreporter, stale=stale
-        )
+    guard = _installed_guard(config)
+    if guard is None:
+        return
+    build_report.report_violations(
+        terminalreporter=terminalreporter,
+        violations=guard.violations,
+        verbose=config.getoption("verbose", 0) > 0,
+    )
+    stale = guard.find_stale_patterns()
+    build_report.report_stale_ignores(terminalreporter=terminalreporter, stale=stale)
 
 
 def pytest_report_header(config: pytest.Config) -> str:
     config_path = config.stash.get(config_path_key, None)
-    return build_report.build_report_header(config_path=config_path)
+    return build_report.render_header(config_path=config_path)

pytest_orm_boundaries-0.2.0/src/pytest_orm_boundaries/build_report.py

@@ -1,30 +0,0 @@
-"""Terminal output: the run header and the stale-ignore notice."""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import pytest
-
-from pytest_orm_boundaries.read_config import CONFIG_FILE_NAME
-
-
-def report_stale_ignores(
-    *, terminalreporter: pytest.TerminalReporter, stale: list[str]
-) -> None:
-    if not stale:
-        return
-    terminalreporter.section("orm-boundaries: stale ignores", yellow=True, bold=True)
-    terminalreporter.write_line(
-        "These [ignore] entries no longer suppress any boundary violation - "
-        f"their files are clean now. Remove them from {CONFIG_FILE_NAME}:",
-        yellow=True,
-    )
-    for pattern in stale:
-        terminalreporter.write_line(f"  - {pattern}", yellow=True)
-
-
-def build_report_header(*, config_path: Path | None) -> str:
-    if config_path is None:
-        return "orm-boundaries: no config file, checks disabled"
-    return f"orm-boundaries: config {config_path}"

pytest_orm_boundaries-0.2.0/src/pytest_orm_boundaries/guard.py

@@ -1,116 +0,0 @@
-"""Django boundary guard: the aggregate-crossing rule and the query
-interception that enforces it.
-
-Patches SQLCompiler.execute_sql to check each query; violations from ignored
-call sites are swallowed, and stale ignores are reported.
-"""
-
-from __future__ import annotations
-
-import functools
-from collections.abc import Callable, Iterable
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-from pytest_orm_boundaries.ignores import IgnoreTracker, find_source_files_in_stack
-from pytest_orm_boundaries.read_config import (
-    load_aggregates_from_config,
-    load_ignored_files_from_config,
-)
-
-if TYPE_CHECKING:
-    from django.db.models import Model
-    from django.db.models.sql.query import Query
-
-
-class BoundaryViolation(Exception):
-    """Raised when a query joins models from more than one aggregate."""
-
-
-class BoundaryGuard:
-    """Intercepts Django's executed queries and enforces the aggregate rule."""
-
-    def __init__(
-        self, *, aggregates_config: dict[str, str], ignore_tracker: IgnoreTracker
-    ) -> None:
-        self._aggregates_config = aggregates_config
-        self._tracker = ignore_tracker
-        self._original_runner: Callable[..., Any] | None = None
-
-    def install(self) -> None:
-        from django.db.models.sql.compiler import SQLCompiler
-
-        original_runner = SQLCompiler.execute_sql
-        self._original_runner = original_runner
-
-        def patched_execute_sql(compiler, *args, **kwargs):
-            self._check_query(query=compiler.query)
-            return original_runner(compiler, *args, **kwargs)
-
-        SQLCompiler.execute_sql = patched_execute_sql
-
-    def restore_original_runner(self) -> None:
-        from django.db.models.sql.compiler import SQLCompiler
-
-        SQLCompiler.execute_sql = self._original_runner
-
-    def find_stale_patterns(self) -> list[str]:
-        return self._tracker.find_stale_patterns()
-
-    def _check_query(self, *, query: Query) -> None:
-        """Raise BoundaryViolation unless the query is clean or ignored."""
-        file_paths: list[str] | None = None
-        if self._tracker.is_active:
-            file_paths = find_source_files_in_stack(root=self._tracker.root)
-            self._tracker.mark_seen(file_paths=file_paths)
-
-        table_to_model = _map_tables_to_models()
-        labels = [
-            table_to_model[table.table_name]._meta.label
-            for table in query.alias_map.values()
-            if table.table_name in table_to_model
-        ]
-
-        try:
-            self._check_boundaries(labels=labels)
-        except BoundaryViolation:
-            if file_paths is None or not self._tracker.has_ignore_for(
-                file_paths=file_paths
-            ):
-                raise
-            self._tracker.mark_used(file_paths=file_paths)
-
-    def _check_boundaries(self, *, labels: Iterable[str]) -> None:
-        aggregate_by_label = {
-            label: aggregate
-            for label in labels
-            if (aggregate := self._aggregates_config.get(label.lower())) is not None
-        }
-        aggregates = set(aggregate_by_label.values())
-        if len(aggregates) <= 1:
-            return
-
-        crossed = ", ".join(sorted(aggregates))
-        joined = ", ".join(sorted(aggregate_by_label.keys()))
-        raise BoundaryViolation(
-            f"aggregate boundaries crossed ({crossed}); joined models: {joined}"
-        )
-
-
-def build_guard(*, rootpath: Path, config_path: Path) -> BoundaryGuard | None:
-    aggregates_by_model = load_aggregates_from_config(path=config_path)
-    if not aggregates_by_model:
-        return None
-
-    ignore_patterns = load_ignored_files_from_config(path=config_path)
-    tracker = IgnoreTracker(patterns=ignore_patterns, root=rootpath)
-
-    return BoundaryGuard(aggregates_config=aggregates_by_model, ignore_tracker=tracker)
-
-
-@functools.cache
-def _map_tables_to_models() -> dict[str, type[Model]]:
-    """Map db_table -> model class for every installed model."""
-    from django.apps import apps
-
-    return {model._meta.db_table: model for model in apps.get_models()}