modwire 9.2.3__tar.gz → 9.2.4__tar.gz

{modwire-9.2.3 → modwire-9.2.4}/.dev/modwire.egg-info/SOURCES.txt

@@ -187,8 +187,8 @@ src/modwire/extraction/dependency/application.py
 src/modwire/extraction/dependency/domain.py
 src/modwire/extraction/dependency/services/__init__.py
 src/modwire/extraction/dependency/services/graph_builder.py
+src/modwire/extraction/dependency/services/import_identity_index.py
 src/modwire/extraction/dependency/services/import_resolver.py
-src/modwire/extraction/dependency/services/suffix_index.py
 src/modwire/extraction/extractors/__init__.py
 src/modwire/extraction/extractors/application.py
 src/modwire/extraction/extractors/domain.py
@@ -326,6 +326,7 @@ tests/extraction/big_projects/resolution_results.json
 tests/extraction/big_projects/results.json
 tests/extraction/big_projects/run.py
 tests/extraction/cache_benchmark/__init__.py
+tests/extraction/cache_benchmark/benchmark_process_timeout.py
 tests/extraction/cache_benchmark/run.py
 tests/extraction/dependency/__init__.py
 tests/extraction/dependency/test_02_invariants.py

{modwire-9.2.3 → modwire-9.2.4}/PKG-INFO

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

{modwire-9.2.3 → modwire-9.2.4}/src/modwire/extraction/dependency/application.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 from wireup import injectable
 
 from ...shared.code.models.dependency_graph import DependencyGraph
-from ...shared.code.models.identity import FileId
+from ...shared.code.models.identity import FileId, ModuleId
 from ...shared.code.models.source_file import SourceFile
 from .domain import GraphBuilder, ImportResolver
 
@@ -17,5 +17,7 @@ class DependencyApplication:
     def build(self, files: dict[FileId, SourceFile]) -> DependencyGraph:
         return self.builder.build(files)
 
-    def resolve(self, files: dict[FileId, SourceFile]) -> dict[FileId, SourceFile]:
-        return self.resolver.resolve(files)
+    def resolve(
+        self, files: dict[FileId, SourceFile], identities: dict[FileId, tuple[ModuleId, ...]]
+    ) -> dict[FileId, SourceFile]:
+        return self.resolver.resolve(files, identities)

{modwire-9.2.3 → modwire-9.2.4}/src/modwire/extraction/dependency/domain.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 
 from ...shared.code.models.dependency_graph import DependencyGraph
-from ...shared.code.models.identity import FileId
+from ...shared.code.models.identity import FileId, ModuleId
 from ...shared.code.models.source_file import SourceFile
 
 
@@ -13,5 +13,7 @@ class GraphBuilder(ABC):
 
 class ImportResolver(ABC):
     @abstractmethod
-    def resolve(self, files: dict[FileId, SourceFile]) -> dict[FileId, SourceFile]:
+    def resolve(
+        self, files: dict[FileId, SourceFile], identities: dict[FileId, tuple[ModuleId, ...]]
+    ) -> dict[FileId, SourceFile]:
         raise NotImplementedError

modwire-9.2.3/src/modwire/extraction/dependency/services/suffix_index.py → modwire-9.2.4/src/modwire/extraction/dependency/services/import_identity_index.py

@@ -1,14 +1,16 @@
 from ....shared.code.models.identity import FileId
 
 
-class SuffixIndex:
+class ImportIdentityIndex:
     def __init__(self) -> None:
+        self._exact: dict[tuple[str, str], set[FileId]] = {}
         self._empty: dict[str, set[FileId]] = {}
         self._terminal: dict[tuple[str, str], set[FileId]] = {}
         self._singleton: dict[tuple[str, str], set[FileId]] = {}
         self._terminal_pair: dict[tuple[str, str, str], set[FileId]] = {}
 
     def add(self, group: str, identity: str, file_id: FileId) -> None:
+        self._exact.setdefault((group, identity), set()).add(file_id)
         if not identity:
             self._empty.setdefault(group, set()).add(file_id)
             return
@@ -19,7 +21,10 @@ class SuffixIndex:
             return
         self._terminal_pair.setdefault((group, parts[-2], parts[-1]), set()).add(file_id)
 
-    def find(self, group: str, identity: str) -> set[FileId]:
+    def exact(self, group: str, identity: str) -> set[FileId]:
+        return set(self._exact.get((group, identity), ()))
+
+    def suffix(self, group: str, identity: str) -> set[FileId]:
         if not identity:
             return set(self._empty.get(group, ()))
         parts = identity.split("/")

{modwire-9.2.3 → modwire-9.2.4}/src/modwire/extraction/dependency/services/import_resolver.py

@@ -3,22 +3,25 @@ from dataclasses import dataclass
 
 from wireup import injectable
 
-from ....shared.code.models.identity import FileId
+from ....shared.code.models.identity import FileId, ModuleId
 from ....shared.code.models.source_file import SourceFile
 from ....shared.code.models.source_import import SourceImport
 from ..domain import ImportResolver
-from .suffix_index import SuffixIndex
+from .import_identity_index import ImportIdentityIndex
 
 
 @injectable(as_type=ImportResolver)
 @dataclass(frozen=True)
 class SourceImportResolver(ImportResolver):
-    def resolve(self, files: dict[FileId, SourceFile]) -> dict[FileId, SourceFile]:
-        modules = SuffixIndex()
-        symbols = SuffixIndex()
+    def resolve(
+        self, files: dict[FileId, SourceFile], identities: dict[FileId, tuple[ModuleId, ...]]
+    ) -> dict[FileId, SourceFile]:
+        modules = ImportIdentityIndex()
+        symbols = ImportIdentityIndex()
         for file_id, source_file in files.items():
             module = self._normalize(source_file.module_id)
-            modules.add("", module, file_id)
+            for identity in identities[file_id]:
+                modules.add("", self._normalize(identity), file_id)
             parent = module.rsplit("/", 1)[0] if "/" in module else ""
             for exported in source_file.exports:
                 symbols.add(exported.name.casefold(), parent, file_id)
@@ -31,14 +34,10 @@ class SourceImportResolver(ImportResolver):
             for file_id, source_file in files.items()
         }
 
-    def _resolve_import(self, imported: SourceImport, modules: SuffixIndex, symbols: SuffixIndex) -> SourceImport:
-        specifier = self._normalize(imported.normalized_path)
-        candidates = modules.find("", specifier)
-        if imported.crossing_type == "symbol" and imported.imported_symbols:
-            symbol_names = {symbol.name.casefold() for symbol in imported.imported_symbols}
-            imported_parent = self._normalize(imported.join_key)
-            for symbol_name in symbol_names:
-                candidates.update(symbols.find(symbol_name, imported_parent))
+    def _resolve_import(
+        self, imported: SourceImport, modules: ImportIdentityIndex, symbols: ImportIdentityIndex
+    ) -> SourceImport:
+        candidates = self._candidates(imported, modules, symbols)
         if len(candidates) == 1:
             return imported.model_copy(update={"resolution": "resolved", "target_file_id": next(iter(candidates))})
         return imported.model_copy(
@@ -48,6 +47,30 @@ class SourceImportResolver(ImportResolver):
             }
         )
 
+    def _candidates(
+        self, imported: SourceImport, modules: ImportIdentityIndex, symbols: ImportIdentityIndex
+    ) -> set[FileId]:
+        specifier = self._normalize(imported.normalized_path)
+        candidates = modules.exact("", specifier)
+        if candidates:
+            return candidates
+        if imported.crossing_type == "symbol" and imported.imported_symbols:
+            symbol_names = {symbol.name.casefold() for symbol in imported.imported_symbols}
+            imported_parent = self._normalize(imported.join_key)
+            for symbol_name in symbol_names:
+                candidates.update(symbols.exact(symbol_name, imported_parent))
+        if candidates:
+            return candidates
+        candidates = modules.suffix("", specifier)
+        if candidates:
+            return candidates
+        if imported.crossing_type == "symbol" and imported.imported_symbols:
+            symbol_names = {symbol.name.casefold() for symbol in imported.imported_symbols}
+            imported_parent = self._normalize(imported.join_key)
+            for symbol_name in symbol_names:
+                candidates.update(symbols.suffix(symbol_name, imported_parent))
+        return candidates
+
     def _normalize(self, value: str) -> str:
         parts = str(value).replace("\\", "/").strip("/").split("/")
         return "/".join(re.sub("[^a-z0-9]", "", part.casefold()) for part in parts)

{modwire-9.2.3 → modwire-9.2.4}/src/modwire/extraction/extractors/application.py

@@ -32,7 +32,13 @@ class ExtractorsApplication:
         return ExtractionRequest(root=root, runtime=extractor.runtime, batch_config=extractor.batch_config)
 
     def generate_map(self, language: str, extraction: SourceExtraction) -> CodeMap:
-        files = self.dependency.resolve(extraction.files)
+        if language not in self.extractors:
+            raise ValueError(f"Language is not supported: {language}")
+        extractor = self.extractors[language]
+        identities = {
+            file_id: extractor.module_identities(source_file) for file_id, source_file in extraction.files.items()
+        }
+        files = self.dependency.resolve(extraction.files, identities)
         resolved = extraction.model_copy(update={"files": files})
         return CodeMap(language=language, extraction=resolved, dependency_graph=self.dependency.build(files))
 

{modwire-9.2.3 → modwire-9.2.4}/src/modwire/extraction/extractors/domain.py

@@ -1,6 +1,8 @@
 import ast
 from abc import ABC, abstractmethod
 
+from ...shared.code.models.identity import ModuleId
+from ...shared.code.models.source_file import SourceFile
 from .models.batch_config import BatchConfig
 from .models.extractor_runtime import ExtractorRuntime
 from .models.python_call_context import PythonCallContext
@@ -28,3 +30,7 @@ class SourceExtractor(ABC):
     @abstractmethod
     def batch_config(self) -> BatchConfig:
         raise NotImplementedError
+
+    @abstractmethod
+    def module_identities(self, source_file: SourceFile) -> tuple[ModuleId, ...]:
+        raise NotImplementedError

{modwire-9.2.3 → modwire-9.2.4}/src/modwire/extraction/extractors/services/php_extractor.py

@@ -2,6 +2,8 @@ from dataclasses import dataclass
 
 from wireup import injectable
 
+from ....shared.code.models.identity import ModuleId
+from ....shared.code.models.source_file import SourceFile
 from ..domain import SourceExtractor
 from ..models.batch_config import BatchConfig
 from ..models.extractor_resource import ExtractorResource
@@ -24,3 +26,6 @@ class PhpExtractor(SourceExtractor):
     @property
     def batch_config(self) -> BatchConfig:
         return BatchConfig(size=500, parallel_threshold=500, parallel_size=500, max_workers=16, output_format="jsonl")
+
+    def module_identities(self, source_file: SourceFile) -> tuple[ModuleId, ...]:
+        return (source_file.module_id,)

{modwire-9.2.3 → modwire-9.2.4}/src/modwire/extraction/extractors/services/python_extractor.py

@@ -3,6 +3,8 @@ from dataclasses import dataclass
 
 from wireup import injectable
 
+from ....shared.code.models.identity import ModuleId
+from ....shared.code.models.source_file import SourceFile
 from ..domain import SourceExtractor
 from ..models.batch_config import BatchConfig
 from ..models.extractor_resource import ExtractorResource
@@ -25,3 +27,10 @@ class PythonExtractor(SourceExtractor):
     @property
     def batch_config(self) -> BatchConfig:
         return BatchConfig(size=500, output_format="json")
+
+    def module_identities(self, source_file: SourceFile) -> tuple[ModuleId, ...]:
+        module_id = source_file.module_id
+        value = str(module_id)
+        if value == "__init__" or not value.endswith("/__init__"):
+            return (module_id,)
+        return (module_id, ModuleId(value.rsplit("/", 1)[0]))

{modwire-9.2.3 → modwire-9.2.4}/src/modwire/extraction/extractors/services/type_script_extractor.py

@@ -2,6 +2,8 @@ from dataclasses import dataclass
 
 from wireup import injectable
 
+from ....shared.code.models.identity import ModuleId
+from ....shared.code.models.source_file import SourceFile
 from ..domain import SourceExtractor
 from ..models.batch_config import BatchConfig
 from ..models.extractor_resource import ExtractorResource
@@ -24,3 +26,6 @@ class TypeScriptExtractor(SourceExtractor):
     @property
     def batch_config(self) -> BatchConfig:
         return BatchConfig(size=500, parallel_threshold=1000, parallel_size=500, max_workers=16, output_format="jsonl")
+
+    def module_identities(self, source_file: SourceFile) -> tuple[ModuleId, ...]:
+        return (source_file.module_id,)

modwire-9.2.4/tests/extraction/cache_benchmark/benchmark_process_timeout.py

@@ -0,0 +1,6 @@
+class BenchmarkProcessTimeout(RuntimeError):
+    def __init__(self, scenario: str, phase: str, limit_seconds: float) -> None:
+        self.scenario = scenario
+        self.phase = phase
+        self.limit_seconds = limit_seconds
+        super().__init__(f"benchmark exceeded its {limit_seconds:.3f}s process budget during {scenario}.{phase}")

{modwire-9.2.3 → modwire-9.2.4}/tests/extraction/cache_benchmark/run.py

@@ -12,13 +12,7 @@ from typing import Any
 
 from modwire.application import CacheOptions, ModwireApplication, ScanPolicy
 
-
-class BenchmarkProcessTimeout(RuntimeError):
-    def __init__(self, scenario: str, phase: str, limit_seconds: float) -> None:
-        self.scenario = scenario
-        self.phase = phase
-        self.limit_seconds = limit_seconds
-        super().__init__(f"benchmark exceeded its {limit_seconds:.3f}s process budget during {scenario}.{phase}")
+from .benchmark_process_timeout import BenchmarkProcessTimeout
 
 
 class CacheBenchmark:

{modwire-9.2.3 → modwire-9.2.4}/tests/extraction/dependency/test_02_invariants.py

@@ -28,7 +28,16 @@ class TestDependencyInvariants(ExtractionTestCase):
         request = self.application.extraction.request(language, str(root))
         extraction = self.application.cli.extract(request, self.scan_policy())
         result = self.application.extraction.generate_map(language, extraction)
-        modules = [(normalize(source.module_id), file_id) for file_id, source in extraction.files.items()]
+        modules = [
+            (identity, file_id)
+            for file_id, source in extraction.files.items()
+            for module in (normalize(source.module_id),)
+            for identity in (
+                (module, module.rsplit("/", 1)[0])
+                if language == "python" and module.endswith("/__init__")
+                else (module,)
+            )
+        ]
         symbols = [
             (module.rsplit("/", 1)[0] if "/" in module else "", exported.name.casefold(), file_id)
             for file_id, source in extraction.files.items()
@@ -38,8 +47,19 @@ class TestDependencyInvariants(ExtractionTestCase):
         for file_id, source in extraction.files.items():
             for actual, imported in zip(result.extraction.files[file_id].imports, source.imports, strict=True):
                 specifier = normalize(imported.normalized_path)
-                candidates = {target for module, target in modules if same_suffix(module, specifier)}
+                candidates = {target for module, target in modules if module == specifier}
                 if imported.crossing_type == "symbol" and imported.imported_symbols:
+                    names = {symbol.name.casefold() for symbol in imported.imported_symbols}
+                    parent = normalize(imported.join_key)
+                    if not candidates:
+                        candidates.update(
+                            target
+                            for module_parent, symbol_name, target in symbols
+                            if symbol_name in names and module_parent == parent
+                        )
+                if not candidates:
+                    candidates = {target for module, target in modules if same_suffix(module, specifier)}
+                if not candidates and imported.crossing_type == "symbol" and imported.imported_symbols:
                     names = {symbol.name.casefold() for symbol in imported.imported_symbols}
                     parent = normalize(imported.join_key)
                     candidates.update(
@@ -57,7 +77,45 @@ class TestDependencyInvariants(ExtractionTestCase):
                 )
                 assert (actual.resolution, actual.target_file_id) == (expected_resolution, expected_target)
 
-    def test_ambiguous_module_suffix_does_not_choose_an_arbitrary_target(self) -> None:
+    def test_exact_module_and_package_identities_win_over_suffix_candidates(self) -> None:
+        result = self.extract(
+            {
+                "example/widgets/api/controllers.py": """
+from ...security.adapters.http import SecurityPermission
+from ..services import WidgetsService
+from ..services.approvals import ApprovalView
+from ..services.audit.model import AuditEventPage
+from ..services.facade import WidgetsService
+""",
+                "example/widgets/services/__init__.py": "class WidgetsService:\n    pass\n",
+                "example/widgets/services/facade.py": "class WidgetsService:\n    pass\n",
+                "example/widgets/services/approvals/__init__.py": "class ApprovalView:\n    pass\n",
+                "example/widgets/services/audit/model.py": "class AuditEventPage:\n    pass\n",
+                "example/security/adapters/http/__init__.py": "class SecurityPermission:\n    pass\n",
+                "example/security/adapters/http/permissions.py": "class SecurityPermission:\n    pass\n",
+                "example/mcp/services/operations/adapters/http.py": "class ExampleHttpAdapter:\n    pass\n",
+                "example/other/services/facade.py": "class ExampleService:\n    pass\n",
+            }
+        )
+        edges = {
+            str(item.edge.specifier): (item.edge.resolution, item.edge.to_id)
+            for item in result.outgoing_dependencies("example/widgets/api/controllers.py").all()
+        }
+        assert edges == {
+            "example/security/adapters/http": ("resolved", "example/security/adapters/http/__init__.py"),
+            "example/widgets/services": ("resolved", "example/widgets/services/__init__.py"),
+            "example/widgets/services/approvals": (
+                "resolved",
+                "example/widgets/services/approvals/__init__.py",
+            ),
+            "example/widgets/services/audit/model": (
+                "resolved",
+                "example/widgets/services/audit/model.py",
+            ),
+            "example/widgets/services/facade": ("resolved", "example/widgets/services/facade.py"),
+        }
+
+    def test_exact_module_identity_wins_over_duplicate_suffix(self) -> None:
         result = self.extract(
             {
                 "example_first/example_package/example_value.py": "class ExampleValue:\n    pass\n",
@@ -66,6 +124,19 @@ class TestDependencyInvariants(ExtractionTestCase):
             }
         )
         edge = result.dependency_edges().first().edge
+        assert edge.resolution == "resolved"
+        assert edge.to_id == "example_first/example_package/example_value.py"
+        assert result.tracked_dependency_edges().count() == 1
+
+    def test_genuinely_ambiguous_module_suffix_does_not_choose_an_arbitrary_target(self) -> None:
+        result = self.extract(
+            {
+                "example_first/example_package/example_value.py": "class ExampleValue:\n    pass\n",
+                "example_second/example_package/example_value.py": "class ExampleValue:\n    pass\n",
+                "example_consumer.py": "from example_package.example_value import ExampleValue\n",
+            }
+        )
+        edge = result.dependency_edges().first().edge
         assert edge.resolution == "unresolved"
         assert edge.to_id is None
         assert not result.tracked_dependency_edges().all()