modwire 9.2.0__tar.gz → 9.2.2__tar.gz

{modwire-9.2.0 → modwire-9.2.2}/.dev/modwire.egg-info/SOURCES.txt

@@ -120,10 +120,9 @@ src/modwire/cli/cache/models/cache_entry.py
 src/modwire/cli/cache/models/cache_key.py
 src/modwire/cli/cache/models/cache_options.py
 src/modwire/cli/cache/models/cache_outcome.py
+src/modwire/cli/cache/models/cache_stage.py
 src/modwire/cli/cache/models/cached_result.py
 src/modwire/cli/cache/models/extraction_snapshot.py
-src/modwire/cli/cache/models/source_entry.py
-src/modwire/cli/cache/models/source_inventory.py
 src/modwire/cli/cache/services/__init__.py
 src/modwire/cli/cache/services/cache_codec.py
 src/modwire/cli/cache/services/cache_identity.py
@@ -148,6 +147,8 @@ src/modwire/cli/pipeline/models/extractor_command_input.py
 src/modwire/cli/pipeline/models/extractor_source_input.py
 src/modwire/cli/pipeline/models/report_pipeline_context.py
 src/modwire/cli/pipeline/models/scan_policy.py
+src/modwire/cli/pipeline/models/source_entry.py
+src/modwire/cli/pipeline/models/source_inventory.py
 src/modwire/cli/pipeline/services/__init__.py
 src/modwire/cli/pipeline/services/batch_source_reader.py
 src/modwire/cli/pipeline/services/callables_insight.py

{modwire-9.2.0 → modwire-9.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modwire
-Version: 9.2.0
+Version: 9.2.2
 Summary: Code extraction, architecture analysis and the Modwire CLI.
 Author: Tomasz Szpak
 License-Expression: MIT

{modwire-9.2.0 → modwire-9.2.2}/src/modwire/application.py

@@ -11,7 +11,8 @@ from .architecture.facade import ArchitectureFacade
 from .architecture.report.models.report_catalog import ReportCatalog
 from .architecture.report.models.report_node import ReportNode
 from .cli.cache.models.cache_options import CacheOptions
-from .cli.cache.models.cache_outcome import CacheOutcome, CacheStage
+from .cli.cache.models.cache_outcome import CacheOutcome
+from .cli.cache.models.cache_stage import CacheStage
 from .cli.cache.models.cached_result import CachedResult
 from .cli.facade import CliFacade
 from .cli.pipeline.models.scan_policy import ScanPolicy

{modwire-9.2.0 → modwire-9.2.2}/src/modwire/architecture/boundaries/services/no_reentry_flow_analyzer.py

@@ -9,6 +9,12 @@ from ..domain import BaseFlowAnalyzer, FlowAnalyzerInterface
 from ..models.flow_violation import FlowViolation
 
 
+@dataclass(frozen=True)
+class NoReentryTraversalState:
+    source_id: str
+    exited_modules: frozenset[str]
+
+
 @injectable(as_type=FlowAnalyzerInterface, qualifier="no_reentry")
 @dataclass(frozen=True)
 class NoReentryFlowAnalyzer(FlowAnalyzerInterface, BaseFlowAnalyzer):
@@ -24,12 +30,14 @@ class NoReentryFlowAnalyzer(FlowAnalyzerInterface, BaseFlowAnalyzer):
         if not architecture_map.realm.module_tag:
             return ()
         violations: list[FlowViolation] = []
+        visited: set[NoReentryTraversalState] = set()
         for root in self.roots(architecture_map):
             self.walk_dependencies(
                 architecture_map=architecture_map,
                 source_id=root,
                 path=(root,),
                 exited_modules=frozenset(),
+                visited=visited,
                 violations=violations,
             )
         return self.dedupe(violations)
@@ -41,8 +49,8 @@ class NoReentryFlowAnalyzer(FlowAnalyzerInterface, BaseFlowAnalyzer):
             if architecture_map.code_map.incoming_dependencies(FileId(source_id)).count() == 0
         )
         if roots:
-            return roots
-        return architecture_map.code_map.source_ids()
+            return tuple(sorted(roots))
+        return tuple(sorted(architecture_map.code_map.source_ids()))
 
     def walk_dependencies(
         self,
@@ -50,10 +58,23 @@ class NoReentryFlowAnalyzer(FlowAnalyzerInterface, BaseFlowAnalyzer):
         source_id: str,
         path: tuple[str, ...],
         exited_modules: frozenset[str],
+        visited: set[NoReentryTraversalState],
         violations: list[FlowViolation],
     ) -> None:
+        state = NoReentryTraversalState(source_id=source_id, exited_modules=exited_modules)
+        if state in visited:
+            return
+        visited.add(state)
         source_module = self.module_for(architecture_map, source_id)
-        for dependency in architecture_map.code_map.outgoing_dependencies(FileId(source_id)).all():
+        dependencies = sorted(
+            architecture_map.code_map.outgoing_dependencies(FileId(source_id)).all(),
+            key=lambda dependency: (
+                dependency.edge.to_id or "",
+                dependency.edge.specifier,
+                dependency.edge.kind,
+            ),
+        )
+        for dependency in dependencies:
             target_id = dependency.edge.to_id
             if target_id is None:
                 continue
@@ -69,14 +90,16 @@ class NoReentryFlowAnalyzer(FlowAnalyzerInterface, BaseFlowAnalyzer):
                         violation_index=len(path),
                         rule_name=self.rule_name(architecture_map),
                         message="module layer re-entered after exit",
+                        source_module=source_module,
+                        target_module=target_module,
                     )
                 )
                 continue
-            if target_id not in path:
-                self.walk_dependencies(
-                    architecture_map=architecture_map,
-                    source_id=target_id,
-                    path=(*path, target_id),
-                    exited_modules=next_exited,
-                    violations=violations,
-                )
+            self.walk_dependencies(
+                architecture_map=architecture_map,
+                source_id=target_id,
+                path=(*path, target_id),
+                exited_modules=next_exited,
+                visited=visited,
+                violations=violations,
+            )

{modwire-9.2.0 → modwire-9.2.2}/src/modwire/cli/cache/application.py

@@ -18,19 +18,14 @@ from ..pipeline.models.scan_policy import ScanPolicy
 from .domain import CacheStorage
 from .models.cache_key import CacheKey
 from .models.cache_options import CacheOptions
-from .models.cache_outcome import CacheOutcome, CacheStage
+from .models.cache_outcome import CacheOutcome
+from .models.cache_stage import CacheStage
 from .models.cached_result import CachedResult
 from .models.extraction_snapshot import ExtractionSnapshot
 from .services.cache_codec import CacheCodec
 from .services.cache_identity import CacheIdentity
 
 
-@dataclass(frozen=True)
-class _CacheRead:
-    value: object | None
-    invalidated: bool
-
-
 @injectable
 @dataclass(frozen=True)
 class CacheApplication:
@@ -57,17 +52,17 @@ class CacheApplication:
         invalidated = 0
         for entry in inventory.entries:
             key = keys[entry.source_id]
-            cached = self._read(options, key)
+            cached_value, cached_invalidated = self._read(options, key)
             try:
-                source_file = SourceFile.model_validate(cached.value)
+                source_file = SourceFile.model_validate(cached_value)
                 if source_file.file_id != entry.source_id:
                     raise ValueError("Cached source identity does not match its key.")
                 files[entry.source_id] = source_file
                 hits += 1
             except (TypeError, ValueError, ValidationError):
-                if cached.value is not None and not cached.invalidated:
+                if cached_value is not None and not cached_invalidated:
                     self.storage.delete(options, key)
-                invalidated += int(cached.invalidated or cached.value is not None)
+                invalidated += int(cached_invalidated or cached_value is not None)
                 misses.append(entry.source_id)
 
         if misses or not inventory.entries:
@@ -128,19 +123,19 @@ class CacheApplication:
 
     def code_map(self, snapshot: ExtractionSnapshot, options: CacheOptions) -> CachedResult[CodeMap | None]:
         key = self.identity.code_map("", snapshot.manifest)
-        cached = self._read(options, key)
+        cached_value, cached_invalidated = self._read(options, key)
         try:
-            value = CodeMap.model_validate(cached.value)
+            value = CodeMap.model_validate(cached_value)
             outcome = CacheOutcome(stage=CacheStage.CODE_MAP, namespace=options.namespace, hits=1)
         except (TypeError, ValueError, ValidationError):
-            if cached.value is not None and not cached.invalidated:
+            if cached_value is not None and not cached_invalidated:
                 self.storage.delete(options, key)
             value = None
             outcome = CacheOutcome(
                 stage=CacheStage.CODE_MAP,
                 namespace=options.namespace,
                 misses=1,
-                invalidated=int(cached.invalidated or cached.value is not None),
+                invalidated=int(cached_invalidated or cached_value is not None),
             )
         return CachedResult[CodeMap | None](value=value, outcomes=(outcome,))
 
@@ -152,9 +147,8 @@ class CacheApplication:
         self, code_map: CodeMap, config: ArchitectureConfig, options: CacheOptions
     ) -> CachedResult[tuple[ReportNode, ...] | None]:
         key = self.identity.reports(code_map, config)
-        cached = self._read(options, key)
-        cached_value: object | None = cached.value
-        invalidated = cached.invalidated or cached_value is not None
+        cached_value, cached_invalidated = self._read(options, key)
+        invalidated = cached_invalidated or cached_value is not None
         try:
             if not isinstance(cached_value, list):
                 raise ValueError("Cached reports must be a list.")
@@ -162,7 +156,7 @@ class CacheApplication:
             value = tuple(sorted(reports, key=lambda item: (item.metadata.order, item.metadata.id)))
             outcome = CacheOutcome(stage=CacheStage.REPORTS, namespace=options.namespace, hits=1)
         except (AttributeError, ImportError, KeyError, TypeError, ValueError, ValidationError):
-            if cached_value is not None and not cached.invalidated:
+            if cached_value is not None and not cached_invalidated:
                 self.storage.delete(options, key)
             value = None
             outcome = CacheOutcome(
@@ -202,15 +196,15 @@ class CacheApplication:
             self.storage.delete(options, entry.key)
             total -= entry.size
 
-    def _read(self, options: CacheOptions, key: CacheKey) -> _CacheRead:
+    def _read(self, options: CacheOptions, key: CacheKey) -> tuple[object | None, bool]:
         payload = self.storage.read(options, key)
         if payload is None:
-            return _CacheRead(value=None, invalidated=False)
+            return None, False
         value = self.codec.decode(key, payload)
         if value is None:
             self.storage.delete(options, key)
-            return _CacheRead(value=None, invalidated=True)
-        return _CacheRead(value=value, invalidated=False)
+            return None, True
+        return value, False
 
     def _write(self, options: CacheOptions, key: CacheKey, value: object) -> None:
         self.storage.write(options, key, self.codec.encode(key, value))

{modwire-9.2.0 → modwire-9.2.2}/src/modwire/cli/cache/models/cache_outcome.py

@@ -1,16 +1,7 @@
-from enum import StrEnum
-
 from pydantic import field_validator
 
 from ....shared.values.models.value_model import ValueModel
-
-
-class CacheStage(StrEnum):
-    """Public stages reported by cached Modwire operations."""
-
-    EXTRACTION = "extraction"
-    CODE_MAP = "code-map"
-    REPORTS = "reports"
+from .cache_stage import CacheStage
 
 
 class CacheOutcome(ValueModel):

modwire-9.2.2/src/modwire/cli/cache/models/cache_stage.py

@@ -0,0 +1,9 @@
+from enum import StrEnum
+
+
+class CacheStage(StrEnum):
+    """Public stages reported by cached Modwire operations."""
+
+    EXTRACTION = "extraction"
+    CODE_MAP = "code-map"
+    REPORTS = "reports"

{modwire-9.2.0 → modwire-9.2.2}/src/modwire/cli/cache/models/cached_result.py

@@ -1,7 +1,8 @@
 from pydantic import field_validator
 
 from ....shared.values.models.value_model import ValueModel
-from .cache_outcome import CacheOutcome, CacheStage
+from .cache_outcome import CacheOutcome
+from .cache_stage import CacheStage
 
 
 class CachedResult[Result](ValueModel):

{modwire-9.2.0 → modwire-9.2.2}/src/modwire/cli/cache/services/cache_identity.py

@@ -11,8 +11,8 @@ from ....architecture.config.models.architecture_config import ArchitectureConfi
 from ....extraction.extractors.models.extraction_request import ExtractionRequest
 from ....shared.code.models.code_map import CodeMap
 from ...cache.models.cache_key import CacheKey, CacheKind
-from ...cache.models.source_entry import SourceEntry
 from ...pipeline.models.scan_policy import ScanPolicy
+from ...pipeline.models.source_entry import SourceEntry
 
 
 @injectable

{modwire-9.2.0 → modwire-9.2.2}/src/modwire/cli/pipeline/domain.py

@@ -5,9 +5,9 @@ from ...extraction.extractors.models.extractor_runtime import ExtractorRuntime
 from ...shared.code.models.identity import FileId
 from ...shared.code.models.source_extraction import SourceExtraction
 from ...shared.code.models.source_file import SourceFile
-from ..cache.models.source_inventory import SourceInventory
 from .models.report_pipeline_context import ReportPipelineContext
 from .models.scan_policy import ScanPolicy
+from .models.source_inventory import SourceInventory
 
 
 class ReportPipelineStep(ABC):

{modwire-9.2.0 → modwire-9.2.2}/src/modwire/cli/pipeline/services/batch_source_reader.py

@@ -20,10 +20,10 @@ from ....shared.code.models.duplicate_identity_error import DuplicateIdentityErr
 from ....shared.code.models.identity import FileId, ModuleId
 from ....shared.code.models.source_extraction import SourceExtraction
 from ....shared.code.models.source_file import SourceFile
-from ...cache.models.source_entry import SourceEntry
-from ...cache.models.source_inventory import SourceInventory
 from ..domain import SourceReader
 from ..models.scan_policy import ScanPolicy
+from ..models.source_entry import SourceEntry
+from ..models.source_inventory import SourceInventory
 
 
 @injectable(as_type=SourceReader)

{modwire-9.2.0 → modwire-9.2.2}/tests/architecture/base_test.py

@@ -10,4 +10,4 @@ class ArchitectureTestCase(ServiceTestCase):
         return {}
 
     def queryable_map(self, paths: tuple[str, ...], edges: tuple[tuple[str, str | None, str, str], ...]):
-        return CodeMapFactory.queryable({path: self.source_file(path) for path in paths}, edges)
+        return CodeMapFactory().queryable({path: self.source_file(path) for path in paths}, edges)

modwire-9.2.2/tests/architecture/boundaries/test_04_paths.py

@@ -0,0 +1,143 @@
+import time
+
+import pytest
+
+from .base_test import BoundaryTestCase
+
+
+class TestFlowPaths(BoundaryTestCase):
+    @pytest.mark.parametrize("reverse", (False, True))
+    def test_layer_order_distinguishes_forward_and_backward_edges(self, reverse: bool) -> None:
+        config = self.application.configure(
+            {
+                "boundaries": {
+                    "tags": [
+                        {"name": "example-entry", "match": "src/example_entry"},
+                        {"name": "example-core", "match": "src/example_core"},
+                    ],
+                    "flow": {
+                        "layers": ["example-entry", "example-core"],
+                        "analyzers": ["backward-flow"],
+                    },
+                },
+                "shape": {"realms": [{"name": "example-source", "match": "src"}]},
+            }
+        )
+        paths = ("src/example_entry/example_entry.source", "src/example_core/example_core.source")
+        source, target = tuple(reversed(paths)) if reverse else paths
+        result = self.violations(config, source, target)
+        assert result == ((source, target),) if reverse else result == ()
+
+    @pytest.mark.parametrize("reenters", (False, True))
+    def test_reentry_reports_the_complete_dependency_path(self, reenters: bool) -> None:
+        config = self.application.configure(
+            {
+                "boundaries": {
+                    "tags": [{"name": "example-module", "match": "src/*"}],
+                    "flow": {"module_tag": "example-module", "analyzers": ["no-reentry"]},
+                },
+                "shape": {"realms": [{"name": "example-source", "match": "src"}]},
+            }
+        )
+        target_module = "example_first" if reenters else "example_third"
+        paths = (
+            "src/example_first/example_entry.source",
+            "src/example_second/example_middle.source",
+            f"src/{target_module}/example_target.source",
+        )
+        edges = tuple((paths[a], paths[b], "resolved", "example.target") for a, b in ((0, 1), (1, 2)))
+        report = self.report("architecture.violations.flow", config, self.queryable_map(paths, edges))
+        assert tuple(item.path for item in report.violations) == ((paths,) if reenters else ())
+        if reenters:
+            assert report.violations[0].violation_index == 2
+            assert report.violations[0].violation_type == "no-reentry"
+            assert report.violations[0].source_module == "example_second"
+            assert report.violations[0].target_module == "example_first"
+
+    def test_reentry_analysis_bounds_converging_dependency_paths(self) -> None:
+        config = self.application.configure(
+            {
+                "boundaries": {
+                    "tags": [{"name": "example-module", "match": "src/*"}],
+                    "flow": {"module_tag": "example-module", "analyzers": ["no-reentry"]},
+                },
+                "shape": {"realms": [{"name": "example-source", "match": "src"}]},
+            }
+        )
+        paths = ["src/example_module/example_root.source"]
+        levels: list[tuple[str, str]] = []
+        for level in range(18):
+            nodes = (
+                f"src/example_module/example_{level}_a.source",
+                f"src/example_module/example_{level}_b.source",
+            )
+            paths.extend(nodes)
+            levels.append(nodes)
+        paths.append("src/example_module/example_target.source")
+        edges: list[tuple[str, str | None, str, str]] = []
+        previous = (paths[0],)
+        for current in levels:
+            edges.extend((source, target, "resolved", "example.target") for source in previous for target in current)
+            previous = current
+        edges.extend((source, paths[-1], "resolved", "example.target") for source in previous)
+        code_map = self.queryable_map(tuple(paths), tuple(edges))
+        started = time.perf_counter()
+        report = self.report("architecture.violations.flow", config, code_map)
+        elapsed = time.perf_counter() - started
+        assert not report.violations
+        assert elapsed < 1.0
+
+    def test_reentry_analysis_preserves_distinct_states_across_repeated_dependencies_and_cycles(self) -> None:
+        config = self.application.configure(
+            {
+                "boundaries": {
+                    "tags": [{"name": "example-module", "match": "src/*"}],
+                    "flow": {"module_tag": "example-module", "analyzers": ["no-reentry"]},
+                },
+                "shape": {"realms": [{"name": "example-source", "match": "src"}]},
+            }
+        )
+        root = "src/example_entry/example_root.source"
+        first = "src/example_first/example_branch.source"
+        second = "src/example_second/example_branch.source"
+        shared = "src/example_shared/example_shared.source"
+        first_target = "src/example_first/example_target.source"
+        second_target = "src/example_second/example_target.source"
+        loop_one = "src/example_entry/example_loop_one.source"
+        loop_two = "src/example_entry/example_loop_two.source"
+        paths = (root, first, second, shared, first_target, second_target, loop_one, loop_two)
+        edges = (
+            (root, first, "resolved", "example.first"),
+            (root, first, "resolved", "example.first"),
+            (root, second, "resolved", "example.second"),
+            (first, shared, "resolved", "example.shared"),
+            (second, shared, "resolved", "example.shared"),
+            (shared, first_target, "resolved", "example.first_target"),
+            (shared, second_target, "resolved", "example.second_target"),
+            (root, loop_one, "resolved", "example.loop_one"),
+            (loop_one, loop_two, "resolved", "example.loop_two"),
+            (loop_two, loop_one, "resolved", "example.loop_one"),
+        )
+        report = self.report("architecture.violations.flow", config, self.queryable_map(paths, edges))
+        assert tuple(
+            (violation.path, violation.violation_index, violation.source_module, violation.target_module)
+            for violation in report.violations
+        ) == (
+            ((root, first, shared, first_target), 3, "example_shared", "example_first"),
+            ((root, second, shared, second_target), 3, "example_shared", "example_second"),
+        )
+
+    def test_cycles_are_reported_once_without_a_graph_root(self) -> None:
+        config = self.application.configure(
+            {
+                "boundaries": {
+                    "tags": [{"name": "example-module", "match": "src/*"}],
+                    "flow": {"module_tag": "example-module", "analyzers": ["no-cycles"]},
+                },
+                "shape": {"realms": [{"name": "example-source", "match": "src"}]},
+            }
+        )
+        paths = ("src/example_first/example_first.source", "src/example_second/example_second.source")
+        edges = tuple((paths[a], paths[b], "resolved", "example.target") for a, b in ((0, 1), (1, 0)))
+        report = self.report("architecture.violations.flow", config, self.queryable_map(paths, edges))
+        assert tuple(item.path for item in report.violations) == (("example_first", "example_second", "example_first"),)

{modwire-9.2.0 → modwire-9.2.2}/tests/architecture/insights/base_test.py

@@ -6,7 +6,7 @@ class InsightTestCase(ArchitectureTestCase):
     def insight(
         self,
         files: dict[str, dict[str, object]],
-        edges: tuple[tuple[str, str | None, str, str], ...] = (),
+        edges: tuple[tuple[str, str | None, str, str], ...],
     ):
-        code_map = CodeMapFactory.queryable(files, edges)
+        code_map = CodeMapFactory().queryable(files, edges)
         return self.report("architecture.insights", self.example_configuration(), code_map)

{modwire-9.2.0 → modwire-9.2.2}/tests/architecture/insights/test_02_invariants.py

@@ -34,14 +34,22 @@ class TestInsightInvariants(InsightTestCase):
             {
                 "example_values.source": {
                     "exports": [
-                        CodeMapFactory.source_export("ExampleUsed"),
-                        CodeMapFactory.source_export("ExampleUnused"),
+                        CodeMapFactory().source_export("ExampleUsed"),
+                        CodeMapFactory().source_export("ExampleUnused"),
                     ]
                 },
                 "example_consumer.source": {
-                    "imports": [CodeMapFactory.source_import("example_values", imported_name="ExampleUsed")]
+                    "imports": [
+                        CodeMapFactory().source_import(
+                            "example_values",
+                            imported_name="ExampleUsed",
+                            is_aliased=False,
+                            imported_symbols=(),
+                        )
+                    ]
                 },
-            }
+            },
+            (),
         ).exports
         assert tuple((item.source_id, item.name) for item in result.unused_exports) == (
             ("example_values.source", "ExampleUnused"),
@@ -53,15 +61,16 @@ class TestInsightInvariants(InsightTestCase):
             {
                 source_id: {
                     "callables": [
-                        CodeMapFactory.source_callable(source_id, "example_target"),
-                        CodeMapFactory.source_callable(source_id, "example_caller"),
+                        CodeMapFactory().source_callable(source_id, "example_target"),
+                        CodeMapFactory().source_callable(source_id, "example_caller"),
                     ],
                     "calls": [
-                        CodeMapFactory.source_call(source_id, "example_caller", "example_target"),
-                        CodeMapFactory.source_call(source_id, "example_caller", "example_target"),
+                        CodeMapFactory().source_call(source_id, "example_caller", "example_target"),
+                        CodeMapFactory().source_call(source_id, "example_caller", "example_target"),
                     ],
                 }
-            }
+            },
+            (),
         ).callables
         entries = {item.source_callable: item for item in result.entries}
         caller = next(item for key, item in entries.items() if key.endswith("example_caller"))
@@ -71,7 +80,7 @@ class TestInsightInvariants(InsightTestCase):
         assert target.calls == ()
 
     def test_empty_project_has_empty_insights(self) -> None:
-        result = self.insight({})
+        result = self.insight({}, ())
         assert result.clusters.clusters == ()
         assert result.hotspots.hotspots == ()
         assert result.callables.entries == ()

{modwire-9.2.0 → modwire-9.2.2}/tests/architecture/shape/base_test.py

@@ -4,4 +4,6 @@ from ..base_test import ArchitectureTestCase
 
 class ShapeTestCase(ArchitectureTestCase):
     def source_file(self, file_id: str) -> dict[str, object]:
-        return {"functions": [CodeMapFactory.symbol("example_function")]}
+        return {
+            "functions": [CodeMapFactory().symbol("example_function", line_count=1, declared_args=0, optional_args=0)]
+        }