modwire 2.0.0__tar.gz → 2.1.0__tar.gz

{modwire-2.0.0 → modwire-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modwire
-Version: 2.0.0
+Version: 2.1.0
 Summary: Extract source-code dependencies and build dependency graphs.
 Author: Tomasz Szpak
 License-Expression: MIT

{modwire-2.0.0 → modwire-2.1.0}/src/modwire/__init__.py

@@ -1,4 +1,10 @@
 from ._version import __version__
+from .callables import (
+    CallableReportEntry,
+    callable_report_entries,
+    render_callable_report,
+    structured_callable_report,
+)
 from .extraction import (
     CodeMap,
     CodeMapSerializationError,
@@ -46,6 +52,7 @@ from .shape import (
 __all__ = [
     "CodeMap",
     "CodeMapSerializationError",
+    "CallableReportEntry",
     "DependencyGraph",
     "Edge",
     "EXTRACTION_SCHEMA_VERSION",
@@ -69,6 +76,7 @@ __all__ = [
     "UnusedExport",
     "__version__",
     "build_dependency_graph",
+    "callable_report_entries",
     "deserialize_code_map",
     "discover_sources",
     "evaluate_shape",
@@ -79,8 +87,10 @@ __all__ = [
     "languages",
     "normalize_source_id",
     "require_runtime",
+    "render_callable_report",
     "runtime_diagnostics",
     "serialize_code_map",
+    "structured_callable_report",
     "supported_languages",
     "validate_shape_config",
 ]

{modwire-2.0.0 → modwire-2.1.0}/src/modwire/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.0.0'
-__version_tuple__ = version_tuple = (2, 0, 0)
+__version__ = version = '2.1.0'
+__version_tuple__ = version_tuple = (2, 1, 0)
 
-__commit_id__ = commit_id = 'gb985fe227'
+__commit_id__ = commit_id = 'g54f33f5a3'

modwire-2.1.0/src/modwire/callables.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+from .definitions import SourceCall, SourceCallable
+from .extraction import CodeMap
+
+
+PathDisplay = Callable[[str], str]
+
+
+@dataclass(frozen=True)
+class CallableReportEntry:
+    source_callable: SourceCallable
+    calls: tuple[SourceCall, ...]
+    callers: tuple[SourceCall, ...]
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "callable": self.source_callable.model_dump(mode="json"),
+            "calls": [source_call.model_dump(mode="json") for source_call in self.calls],
+            "callers": [
+                source_call.model_dump(mode="json") for source_call in self.callers
+            ],
+        }
+
+
+def callable_report_entries(code_map: CodeMap) -> tuple[CallableReportEntry, ...]:
+    return tuple(
+        CallableReportEntry(
+            source_callable=source_callable,
+            calls=tuple(
+                sorted(
+                    code_map.calls_from(source_callable.id),
+                    key=lambda source_call: (
+                        source_call.line,
+                        source_call.target_name,
+                        source_call.expression,
+                    ),
+                )
+            ),
+            callers=tuple(
+                sorted(
+                    code_map.calls_to(source_callable.id),
+                    key=lambda source_call: (
+                        source_call.source_id,
+                        source_call.line,
+                        source_call.source_callable_id,
+                    ),
+                )
+            ),
+        )
+        for source_callable in sorted(
+            (
+                source_callable
+                for source_file in code_map.extraction_result.files.values()
+                for source_callable in source_file.callables
+            ),
+            key=lambda source_callable: (
+                source_callable.source_id,
+                source_callable.line_start,
+                source_callable.qualified_name,
+            ),
+        )
+    )
+
+
+def structured_callable_report(code_map: CodeMap) -> tuple[dict[str, object], ...]:
+    return tuple(entry.to_dict() for entry in callable_report_entries(code_map))
+
+
+def render_callable_report(
+    code_map: CodeMap,
+    *,
+    path_display: PathDisplay = str,
+) -> str:
+    entries = callable_report_entries(code_map)
+    if not entries:
+        return "Callable Report\n\nNo callables found."
+
+    callable_names = {
+        entry.source_callable.id: entry.source_callable.qualified_name
+        for entry in entries
+    }
+    lines = ["Callable Report", ""]
+    current_source_id = ""
+    for entry in entries:
+        source_callable = entry.source_callable
+        if source_callable.source_id != current_source_id:
+            current_source_id = source_callable.source_id
+            lines.extend([f"## {path_display(current_source_id)}", ""])
+        lines.append(
+            "- "
+            f"{source_callable.qualified_name} "
+            f"[{source_callable.kind}] "
+            f"lines {source_callable.line_start}-{source_callable.line_end}"
+        )
+        lines.append("  Calls:")
+        lines.extend(
+            _call_lines(
+                entry.calls,
+                callable_names=callable_names,
+                direction="outgoing",
+                path_display=path_display,
+            )
+        )
+        lines.append("  Called by:")
+        lines.extend(
+            _call_lines(
+                entry.callers,
+                callable_names=callable_names,
+                direction="incoming",
+                path_display=path_display,
+            )
+        )
+        lines.append("")
+    return "\n".join(lines).rstrip()
+
+
+def _call_lines(
+    calls: tuple[SourceCall, ...],
+    *,
+    callable_names: dict[str, str],
+    direction: str,
+    path_display: PathDisplay,
+) -> list[str]:
+    if not calls:
+        return ["  - none"]
+
+    rendered = []
+    for source_call in calls:
+        if direction == "incoming":
+            caller_name = callable_names.get(
+                source_call.source_callable_id,
+                source_call.source_callable_id,
+            )
+            rendered.append(
+                f"  - {caller_name} "
+                f"at {path_display(source_call.source_id)}:{source_call.line}"
+            )
+            continue
+
+        target = (
+            callable_names[source_call.target_callable_id]
+            if source_call.target_callable_id in callable_names
+            else source_call.target_name
+        )
+        rendered.append(
+            f"  - {source_call.expression} -> {target} "
+            f"at {path_display(source_call.source_id)}:{source_call.line} "
+            f"({source_call.resolution})"
+        )
+    return rendered
+
+
+__all__ = [
+    "CallableReportEntry",
+    "callable_report_entries",
+    "render_callable_report",
+    "structured_callable_report",
+]

{modwire-2.0.0 → modwire-2.1.0}/src/modwire/definitions.py

@@ -6,6 +6,19 @@ from pydantic import BaseModel, Field
 ImportCrossingType = Literal["module", "symbol"]
 SourceVisibility = Literal["public", "protected", "private"]
 SourceSignatureKind = Literal["call", "construct", "index"]
+SourceValueDeclarationKind = Literal["assignment", "constant", "property", "unknown"]
+SourceValueKind = Literal["callable", "class", "literal", "object", "unknown"]
+SourceParameterKind = Literal["positional", "vararg", "keyword_only", "kwarg"]
+SourceCallableKind = Literal[
+    "function",
+    "method",
+    "classmethod",
+    "staticmethod",
+    "constructor",
+    "callable_value",
+    "anonymous",
+]
+SourceCallResolution = Literal["resolved", "unresolved", "external", "dynamic"]
 SourceExportKind = Literal[
     "module",
     "class",
@@ -64,6 +77,54 @@ class SourceFunction(BaseModel):
     optional_args: int
 
 
+class SourceValue(BaseModel):
+    name: str
+    visibility: SourceVisibility
+    visibility_intent: SourceVisibility
+    line_count: int
+    declaration_kind: SourceValueDeclarationKind
+    value_kind: SourceValueKind
+    declared_args: int = 0
+    optional_args: int = 0
+
+
+class SourceParameter(BaseModel):
+    name: str
+    annotation: str = ""
+    kind: SourceParameterKind
+    has_default: bool = False
+
+
+class SourceCallable(BaseModel):
+    id: str
+    source_id: str
+    name: str
+    qualified_name: str
+    owner_name: str = ""
+    kind: SourceCallableKind
+    visibility: SourceVisibility
+    visibility_intent: SourceVisibility
+    line_start: int
+    line_end: int
+    line_count: int
+    parameters: list[SourceParameter] = Field(default_factory=list)
+    declared_args: int = 0
+    optional_args: int = 0
+    return_annotation: str = ""
+    decorators: list[str] = Field(default_factory=list)
+    docstring: str = ""
+
+
+class SourceCall(BaseModel):
+    source_callable_id: str
+    target_callable_id: str = ""
+    source_id: str
+    line: int
+    expression: str
+    resolution: SourceCallResolution
+    target_name: str
+
+
 class SourceClassMethod(BaseModel):
     name: str
     visibility: SourceVisibility
@@ -131,6 +192,9 @@ class SourceFile(BaseModel):
     types: list[SourceType] = Field(default_factory=list)
     abstract_classes: list[SourceAbstractClass] = Field(default_factory=list)
     functions: list[SourceFunction]
+    values: list[SourceValue] = Field(default_factory=list)
+    callables: list[SourceCallable] = Field(default_factory=list)
+    calls: list[SourceCall] = Field(default_factory=list)
     line_count: int
     code_line_count: int
     public_symbol_count: int

{modwire-2.0.0 → modwire-2.1.0}/src/modwire/extraction/models.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-from ..definitions import SourceFile
+from ..definitions import SourceCall, SourceCallable, SourceFile
 from ..graph import DependencyGraph, Edge
 from .roots import SourceIdMode
 
@@ -58,6 +58,54 @@ class CodeMap:
     def external_edges(self) -> tuple[Edge, ...]:
         return self.graph.external_edges(self.source_ids())
 
+    def callable_ids(self) -> tuple[str, ...]:
+        return tuple(
+            source_callable.id
+            for source_file in self.extraction_result.files.values()
+            for source_callable in source_file.callables
+        )
+
+    def callable(self, callable_id: str) -> SourceCallable:
+        for source_file in self.extraction_result.files.values():
+            for source_callable in source_file.callables:
+                if source_callable.id == callable_id:
+                    return source_callable
+        raise KeyError(callable_id)
+
+    def calls_from(self, callable_id: str) -> tuple[SourceCall, ...]:
+        return tuple(
+            source_call
+            for source_file in self.extraction_result.files.values()
+            for source_call in source_file.calls
+            if source_call.source_callable_id == callable_id
+        )
+
+    def calls_to(self, callable_id: str) -> tuple[SourceCall, ...]:
+        return tuple(
+            source_call
+            for source_file in self.extraction_result.files.values()
+            for source_call in source_file.calls
+            if source_call.target_callable_id == callable_id
+        )
+
+    def callable_graph(self) -> DependencyGraph:
+        graph = DependencyGraph()
+        callable_ids = set(self.callable_ids())
+        for callable_id in sorted(callable_ids):
+            graph.add_node(callable_id, kind="callable")
+        for source_file in self.extraction_result.files.values():
+            for source_call in source_file.calls:
+                if (
+                    source_call.source_callable_id in callable_ids
+                    and source_call.target_callable_id in callable_ids
+                ):
+                    graph.add_edge(
+                        source_call.source_callable_id,
+                        source_call.target_callable_id,
+                        kind="call",
+                    )
+        return graph
+
     def tracked_only(self) -> CodeMap:
         return self.subgraph(self.source_ids())
 

{modwire-2.0.0 → modwire-2.1.0}/src/modwire/extraction/serialization.py

@@ -7,7 +7,8 @@ from ..graph import DependencyGraph, Edge, Node
 from .models import CodeMap, ExtractionResult, ExtractionSummary
 
 
-CODE_MAP_SCHEMA_VERSION = 1
+CODE_MAP_SCHEMA_VERSION = 2
+SUPPORTED_CODE_MAP_SCHEMA_VERSIONS = {1, CODE_MAP_SCHEMA_VERSION}
 
 
 class CodeMapSerializationError(ValueError):
@@ -55,7 +56,7 @@ def deserialize_code_map(
     cache_key: str = "",
 ) -> CodeMap:
     try:
-        if payload["schema_version"] != CODE_MAP_SCHEMA_VERSION:
+        if payload["schema_version"] not in SUPPORTED_CODE_MAP_SCHEMA_VERSIONS:
             raise CodeMapSerializationError(
                 f"Unsupported CodeMap schema version: {payload['schema_version']}"
             )

{modwire-2.0.0 → modwire-2.1.0}/src/modwire/extractors/base.py

@@ -151,6 +151,9 @@ class SourceExtractor(Protocol):
             types=source_file.types,
             abstract_classes=source_file.abstract_classes,
             functions=source_file.functions,
+            values=source_file.values,
+            callables=source_file.callables,
+            calls=source_file.calls,
             line_count=source_file.line_count,
             code_line_count=source_file.code_line_count,
             public_symbol_count=source_file.public_symbol_count,