modwire-extraction 1.0.0__tar.gz

modwire_extraction-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 9orky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

modwire_extraction-1.0.0/MANIFEST.in

@@ -0,0 +1,5 @@
+include README.md
+recursive-include src/modwire_extraction/extractors/languages *.js *.json *.lock *.mjs *.php *.py *.ts
+recursive-exclude src/modwire_extraction/extractors/languages/typescript/node_modules *
+recursive-exclude src/modwire_extraction/extractors/languages/php/vendor *
+recursive-include tests/fixtures *.py

modwire_extraction-1.0.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: modwire-extraction
+Version: 1.0.0
+Summary: Extraction implementation for modwire.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/9orky/modwire-extraction
+Project-URL: Repository, https://github.com/9orky/modwire-extraction
+Project-URL: Issues, https://github.com/9orky/modwire-extraction/issues
+Keywords: code-analysis,dependency-graph,extraction
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.8
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: pyright>=1.1; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Dynamic: license-file
+
+# modwire-extraction
+
+Extraction implementation for Modwire.
+
+The primary API starts from `ModwireExtraction`:
+
+```python
+from pathlib import Path
+
+from modwire_extraction import ModwireExtraction
+
+queryable_map = ModwireExtraction(Path("src")).generate_queryable_map("python")
+print(queryable_map.source_ids())
+```
+
+Public data and query helpers are exported from:
+
+- `modwire_extraction` for `ModwireExtraction`.
+- `modwire_extraction.code` for `CodeMap`, `QueryableCodeMap`, and query result types.
+- `modwire_extraction.dependency` for dependency graph helpers.
+- `modwire_extraction.extractors` for extractor loading.
+
+## Compatibility notes
+
+The public Python import paths listed above are the supported API surface for
+1.0.0.
+
+Dependency graph edges use normalized import strings. Imports such as
+`domain/model/user` are not represented as the source ID
+`src/domain/model/user`.
+
+Serialized `CodeMap` JSON is intended for same-version interchange in 1.0.0.
+Do not treat the JSON shape as a cross-version compatibility contract yet.
+
+TypeScript and PHP helper build files are included as package data because
+they are part of the bundled extractor runtimes and reproducible maintenance
+path.
+
+## Install
+
+```bash
+pip install modwire-extraction
+```
+
+Python extraction works with the active Python interpreter. TypeScript,
+JavaScript, TSX, and JSX extraction require `node` on `PATH`. PHP extraction
+requires `php` on `PATH`.
+
+## Development
+
+```bash
+python -m pip install -e ".[dev]"
+pytest
+python -m build
+twine check dist/*
+```
+
+Before publishing manually, choose the release version in `pyproject.toml`,
+remove stale local artifacts, build a fresh distribution, and upload only the
+expected version files:
+
+```bash
+rm -rf build dist src/*.egg-info
+python -m build
+twine check dist/*
+twine upload dist/modwire_extraction-1.0.0*
+```
+
+The preferred release path is GitHub Actions. Publish a GitHub Release tagged
+`vX.Y.Z` or `X.Y.Z` after configuring PyPI Trusted Publishing for workflow
+`workflow.yml` and GitHub Environment `pypi`. The release workflow sets the
+package version from the release tag before building.

modwire_extraction-1.0.0/README.md

@@ -0,0 +1,72 @@
+# modwire-extraction
+
+Extraction implementation for Modwire.
+
+The primary API starts from `ModwireExtraction`:
+
+```python
+from pathlib import Path
+
+from modwire_extraction import ModwireExtraction
+
+queryable_map = ModwireExtraction(Path("src")).generate_queryable_map("python")
+print(queryable_map.source_ids())
+```
+
+Public data and query helpers are exported from:
+
+- `modwire_extraction` for `ModwireExtraction`.
+- `modwire_extraction.code` for `CodeMap`, `QueryableCodeMap`, and query result types.
+- `modwire_extraction.dependency` for dependency graph helpers.
+- `modwire_extraction.extractors` for extractor loading.
+
+## Compatibility notes
+
+The public Python import paths listed above are the supported API surface for
+1.0.0.
+
+Dependency graph edges use normalized import strings. Imports such as
+`domain/model/user` are not represented as the source ID
+`src/domain/model/user`.
+
+Serialized `CodeMap` JSON is intended for same-version interchange in 1.0.0.
+Do not treat the JSON shape as a cross-version compatibility contract yet.
+
+TypeScript and PHP helper build files are included as package data because
+they are part of the bundled extractor runtimes and reproducible maintenance
+path.
+
+## Install
+
+```bash
+pip install modwire-extraction
+```
+
+Python extraction works with the active Python interpreter. TypeScript,
+JavaScript, TSX, and JSX extraction require `node` on `PATH`. PHP extraction
+requires `php` on `PATH`.
+
+## Development
+
+```bash
+python -m pip install -e ".[dev]"
+pytest
+python -m build
+twine check dist/*
+```
+
+Before publishing manually, choose the release version in `pyproject.toml`,
+remove stale local artifacts, build a fresh distribution, and upload only the
+expected version files:
+
+```bash
+rm -rf build dist src/*.egg-info
+python -m build
+twine check dist/*
+twine upload dist/modwire_extraction-1.0.0*
+```
+
+The preferred release path is GitHub Actions. Publish a GitHub Release tagged
+`vX.Y.Z` or `X.Y.Z` after configuring PyPI Trusted Publishing for workflow
+`workflow.yml` and GitHub Environment `pypi`. The release workflow sets the
+package version from the release tag before building.

modwire_extraction-1.0.0/pyproject.toml

@@ -0,0 +1,78 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "modwire-extraction"
+version = "1.0.0"
+description = "Extraction implementation for modwire."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11"
+dependencies = [
+    "pydantic>=2.8",
+]
+keywords = ["code-analysis", "dependency-graph", "extraction"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+
+[project.urls]
+Homepage = "https://github.com/9orky/modwire-extraction"
+Repository = "https://github.com/9orky/modwire-extraction"
+Issues = "https://github.com/9orky/modwire-extraction/issues"
+
+[project.optional-dependencies]
+dev = [
+    "build>=1.2",
+    "pyright>=1.1",
+    "pytest>=8",
+    "twine>=5",
+]
+
+[dependency-groups]
+dev = [
+    "pyright>=1.1",
+]
+
+[tool.pyright]
+include = ["src"]
+extraPaths = ["src"]
+venvPath = "."
+venv = ".venv"
+pythonVersion = "3.11"
+typeCheckingMode = "strict"
+reportAbstractUsage = "error"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["src"]
+namespaces = true
+
+[tool.setuptools.package-data]
+"modwire_extraction.extractors.languages.python" = [
+    "*.py",
+]
+"modwire_extraction.extractors.languages.php" = [
+    "*.php",
+    "*.json",
+    "*.lock",
+]
+"modwire_extraction.extractors.languages.typescript" = [
+    "*.js",
+    "*.json",
+    "*.mjs",
+    "*.ts",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

modwire_extraction-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

modwire_extraction-1.0.0/src/modwire_extraction/__init__.py

@@ -0,0 +1,3 @@
+from .extraction import ModwireExtraction
+
+__all__ = ["ModwireExtraction"]

modwire_extraction-1.0.0/src/modwire_extraction/_version.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("modwire-extraction")
+except PackageNotFoundError:
+    __version__ = "0.0.0"

modwire_extraction-1.0.0/src/modwire_extraction/code/__init__.py

@@ -0,0 +1,20 @@
+from .code_map import CodeMap
+from .query import (
+    DependencyEdgeResult,
+    DependencyNodeResult,
+    QueryableCodeMap,
+    QueryBuilder,
+    SourceFileResult,
+    SourceItemResult,
+)
+
+
+__all__ = [
+    "CodeMap",
+    "DependencyEdgeResult",
+    "DependencyNodeResult",
+    "QueryableCodeMap",
+    "QueryBuilder",
+    "SourceFileResult",
+    "SourceItemResult",
+]

modwire_extraction-1.0.0/src/modwire_extraction/code/code_map.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+from ..dependency.graph import DependencyGraph
+from ..extractors.languages.base import SourceExtraction
+
+
+class CodeMap(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    language: str
+    extraction: SourceExtraction
+    dependency_graph: DependencyGraph
+
+    def to_dict(self) -> dict[str, Any]:
+        return self.model_dump(mode="python")
+
+    @classmethod
+    def from_dict(cls, payload: object) -> CodeMap:
+        return cls.model_validate(payload)
+
+    def to_json(self) -> str:
+        return self.model_dump_json()
+
+    @classmethod
+    def from_json(cls, payload: str | bytes) -> CodeMap:
+        return cls.model_validate_json(payload)

modwire_extraction-1.0.0/src/modwire_extraction/code/query.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass
+from typing import Generic, TypeVar
+
+from ..dependency.graph import Edge, Node
+from ..extractors.source import (
+    SourceAbstractClass,
+    SourceCall,
+    SourceCallable,
+    SourceClass,
+    SourceExport,
+    SourceFile,
+    SourceFunction,
+    SourceImport,
+    SourceInterface,
+    SourceType,
+    SourceValue,
+)
+from .code_map import CodeMap
+
+
+T = TypeVar("T")
+SourceItem = TypeVar("SourceItem")
+
+
+class QueryBuilder(Generic[T]):
+    def __init__(
+        self,
+        items: Iterable[T],
+        predicates: tuple[Callable[[T], bool], ...] = (),
+    ):
+        self._items = tuple(items)
+        self._predicates = predicates
+
+    def where(self, predicate: Callable[[T], bool]) -> QueryBuilder[T]:
+        return QueryBuilder(self._items, (*self._predicates, predicate))
+
+    def where_equal(
+        self,
+        selector: Callable[[T], object],
+        expected: object,
+    ) -> QueryBuilder[T]:
+        return self.where(lambda item: selector(item) == expected)
+
+    def where_contains(
+        self,
+        selector: Callable[[T], str],
+        expected: str,
+        *,
+        case_sensitive: bool = True,
+    ) -> QueryBuilder[T]:
+        if case_sensitive:
+            return self.where(lambda item: expected in selector(item))
+
+        lowered = expected.casefold()
+        return self.where(lambda item: lowered in selector(item).casefold())
+
+    def all(self) -> tuple[T, ...]:
+        return tuple(
+            item
+            for item in self._items
+            if all(predicate(item) for predicate in self._predicates)
+        )
+
+    def first(self) -> T | None:
+        for item in self.all():
+            return item
+        return None
+
+    def count(self) -> int:
+        return len(self.all())
+
+
+@dataclass(frozen=True)
+class SourceFileResult:
+    source_id: str
+    file: SourceFile
+
+
+@dataclass(frozen=True)
+class SourceItemResult(Generic[SourceItem]):
+    source_id: str
+    file: SourceFile
+    item: SourceItem
+
+
+@dataclass(frozen=True)
+class DependencyNodeResult:
+    node_id: str
+    node: Node
+    file: SourceFile | None
+
+
+@dataclass(frozen=True)
+class DependencyEdgeResult:
+    edge: Edge
+    source_file: SourceFile | None
+    target_file: SourceFile | None
+
+
+class QueryableCodeMap:
+    def __init__(self, code_map: CodeMap):
+        self.code_map = code_map
+        self.cm = code_map
+
+    def query(self, items: Iterable[T]) -> QueryBuilder[T]:
+        return QueryBuilder(items)
+
+    def source_ids(self) -> tuple[str, ...]:
+        return tuple(self.code_map.extraction.files)
+
+    def has_source_file(self, source_id: str) -> bool:
+        return source_id in self.code_map.extraction.files
+
+    def source_file(self, source_id: str) -> SourceFileResult | None:
+        source_file = self.code_map.extraction.files.get(source_id)
+        if source_file is None:
+            return None
+        return SourceFileResult(source_id=source_id, file=source_file)
+
+    def files(self) -> QueryBuilder[SourceFileResult]:
+        return self.source_files()
+
+    def source_files(self) -> QueryBuilder[SourceFileResult]:
+        return QueryBuilder(
+            SourceFileResult(source_id=source_id, file=source_file)
+            for source_id, source_file in self.code_map.extraction.files.items()
+        )
+
+    def imports(self) -> QueryBuilder[SourceItemResult[SourceImport]]:
+        return self._source_items(lambda source_file: source_file.imports)
+
+    def exports(self) -> QueryBuilder[SourceItemResult[SourceExport]]:
+        return self._source_items(lambda source_file: source_file.exports)
+
+    def classes(self) -> QueryBuilder[SourceItemResult[SourceClass]]:
+        return self._source_items(lambda source_file: source_file.classes)
+
+    def interfaces(self) -> QueryBuilder[SourceItemResult[SourceInterface]]:
+        return self._source_items(lambda source_file: source_file.interfaces)
+
+    def types(self) -> QueryBuilder[SourceItemResult[SourceType]]:
+        return self._source_items(lambda source_file: source_file.types)
+
+    def abstract_classes(self) -> QueryBuilder[SourceItemResult[SourceAbstractClass]]:
+        return self._source_items(lambda source_file: source_file.abstract_classes)
+
+    def functions(self) -> QueryBuilder[SourceItemResult[SourceFunction]]:
+        return self._source_items(lambda source_file: source_file.functions)
+
+    def values(self) -> QueryBuilder[SourceItemResult[SourceValue]]:
+        return self._source_items(lambda source_file: source_file.values)
+
+    def callables(self) -> QueryBuilder[SourceItemResult[SourceCallable]]:
+        return self._source_items(lambda source_file: source_file.callables)
+
+    def calls(self) -> QueryBuilder[SourceItemResult[SourceCall]]:
+        return self._source_items(lambda source_file: source_file.calls)
+
+    def dependency_nodes(self) -> QueryBuilder[DependencyNodeResult]:
+        files = self.code_map.extraction.files
+        return QueryBuilder(
+            DependencyNodeResult(
+                node_id=node_id,
+                node=node,
+                file=files.get(node_id),
+            )
+            for node_id, node in self.code_map.dependency_graph.nodes.items()
+        )
+
+    def dependency_edges(self) -> QueryBuilder[DependencyEdgeResult]:
+        return self._dependency_edges(self.code_map.dependency_graph.edges)
+
+    def outgoing_dependencies(self, source_id: str) -> QueryBuilder[DependencyEdgeResult]:
+        return self._dependency_edges(self.code_map.dependency_graph.outgoing(source_id))
+
+    def incoming_dependencies(self, source_id: str) -> QueryBuilder[DependencyEdgeResult]:
+        return self._dependency_edges(self.code_map.dependency_graph.incoming(source_id))
+
+    def dependencies_between(
+        self,
+        source_id: str,
+        target_id: str,
+    ) -> QueryBuilder[DependencyEdgeResult]:
+        return self._dependency_edges(
+            self.code_map.dependency_graph.edges_between(source_id, target_id)
+        )
+
+    def tracked_dependency_edges(self) -> QueryBuilder[DependencyEdgeResult]:
+        return self._dependency_edges(
+            self.code_map.dependency_graph.tracked_edges(self.source_ids())
+        )
+
+    def external_dependency_edges(self) -> QueryBuilder[DependencyEdgeResult]:
+        return self._dependency_edges(
+            self.code_map.dependency_graph.external_edges(self.source_ids())
+        )
+
+    def _source_items(
+        self,
+        selector: Callable[[SourceFile], Iterable[SourceItem]],
+    ) -> QueryBuilder[SourceItemResult[SourceItem]]:
+        return QueryBuilder(
+            SourceItemResult(source_id=source_id, file=source_file, item=item)
+            for source_id, source_file in self.code_map.extraction.files.items()
+            for item in selector(source_file)
+        )
+
+    def _dependency_edges(
+        self,
+        edges: Iterable[Edge],
+    ) -> QueryBuilder[DependencyEdgeResult]:
+        files = self.code_map.extraction.files
+        return QueryBuilder(
+            DependencyEdgeResult(
+                edge=edge,
+                source_file=files.get(edge.from_id),
+                target_file=files.get(edge.to_id),
+            )
+            for edge in edges
+        )

modwire_extraction-1.0.0/src/modwire_extraction/dependency/__init__.py

@@ -0,0 +1,6 @@
+from .graph import build_dependency_graph
+
+
+__all__ = [
+    "build_dependency_graph",
+]