ctxgraph-code 0.1.3__py3-none-any.whl → 0.2.0__py3-none-any.whl

ctxgraph_code/analyzers/python/importer.py

@@ -4,90 +4,99 @@ import ast
 from pathlib import Path
 from typing import Optional
 
-from ctxgraph_code.graph.models import Edge, Graph, Node
-
-
-def analyze_imports(file_path: Path, root_path: Path) -> Graph:
-    graph = Graph()
+from ctxgraph_code.graph.models import Graph
+
+
+def analyze_imports(
+    file_path: Path,
+    root_path: Path,
+    *,
+    tree: Optional[ast.AST] = None,
+    path_index: Optional[set[str]] = None,
+) -> Graph:
+    # Result containers (not full Graph — caller merges)
+    nodes: list[dict] = []
+    edges: list[dict] = []
     rel_path = _relative_path(file_path, root_path)
     file_node_id = f"file:{rel_path}"
 
-    graph.add_node(
-        Node(
-            id=file_node_id,
-            type="file",
-            name=file_path.name,
-            path=rel_path,
-            summary=None,
-            importance=0.5,
-            size_bytes=file_path.stat().st_size,
-        )
-    )
-
-    try:
-        tree = ast.parse(file_path.read_text(encoding="utf-8", errors="replace"))
-    except SyntaxError:
-        return graph
+    nodes.append(dict(
+        id=file_node_id,
+        type="file",
+        name=file_path.name,
+        path=rel_path,
+        summary=None,
+        importance=0.5,
+        size_bytes=file_path.stat().st_size,
+    ))
+
+    if tree is None:
+        try:
+            tree = ast.parse(file_path.read_text(encoding="utf-8", errors="replace"))
+        except SyntaxError:
+            return Graph.from_batch(nodes, edges)
 
     for node in ast.walk(tree):
         if isinstance(node, ast.Import):
             for alias in node.names:
-                target = _resolve_import_target(alias.name, root_path)
+                target = _resolve_import_target(alias.name, root_path, path_index)
                 if target:
-                    _add_import_edge(graph, rel_path, file_node_id, target, alias.name)
+                    _add_import_edge(nodes, edges, rel_path, file_node_id, target, alias.name)
 
         elif isinstance(node, ast.ImportFrom):
             if node.module is None:
                 continue
             if node.level and node.level > 0:
                 target = _resolve_relative_import(
-                    node.module, node.level, rel_path, root_path
+                    node.module, node.level, rel_path, root_path, path_index
                 )
             else:
-                target = _resolve_import_target(node.module, root_path)
+                target = _resolve_import_target(node.module, root_path, path_index)
 
             if target:
                 for alias in node.names:
                     symbol_name = alias.asname or alias.name
                     edge_label = f"{node.module}.{alias.name}"
                     _add_import_edge(
-                        graph, rel_path, file_node_id, target, edge_label
+                        nodes, edges, rel_path, file_node_id, target, edge_label
                     )
 
-    return graph
+    return Graph.from_batch(nodes, edges)
 
 
 def _add_import_edge(
-    graph: Graph,
+    nodes: list[dict],
+    edges: list[dict],
     source_rel: str,
     source_id: str,
     target_rel: str,
     label: str,
 ):
     target_id = f"file:{target_rel}"
-    if target_id not in graph.nodes:
-        graph.add_node(
-            Node(
-                id=target_id,
-                type="file",
-                name=Path(target_rel).name,
-                path=target_rel,
-                summary=None,
-                importance=0.3,
-                size_bytes=0,
-            )
-        )
-    graph.add_edge(
-        Edge(
-            source_id=source_id,
-            target_id=target_id,
-            relation="imports",
-            weight=1.0,
-        )
-    )
-
-
-def _resolve_import_target(module_name: str, root_path: Path) -> Optional[str]:
+    # Check if target node already in our batch list
+    if not any(n["id"] == target_id for n in nodes):
+        nodes.append(dict(
+            id=target_id,
+            type="file",
+            name=Path(target_rel).name,
+            path=target_rel,
+            summary=None,
+            importance=0.3,
+            size_bytes=0,
+        ))
+    edges.append(dict(
+        source_id=source_id,
+        target_id=target_id,
+        relation="imports",
+        weight=1.0,
+    ))
+
+
+def _resolve_import_target(
+    module_name: str,
+    root_path: Path,
+    path_index: Optional[set[str]] = None,
+) -> Optional[str]:
     package_path = module_name.replace(".", "/")
     root_name = root_path.name
     extensions = [".py", ".pyw"]
@@ -100,16 +109,20 @@ def _resolve_import_target(module_name: str, root_path: Path) -> Optional[str]:
     for base in candidates:
         for ext in extensions:
             candidate = f"{base}{ext}"
-            if _exists_in_project(candidate, root_path):
+            if _exists_in_project(candidate, root_path, path_index):
                 return candidate
             init_candidate = f"{base}/__init__{ext}"
-            if _exists_in_project(init_candidate, root_path):
+            if _exists_in_project(init_candidate, root_path, path_index):
                 return init_candidate
     return None
 
 
 def _resolve_relative_import(
-    module_name: str, level: int, source_rel: str, root_path: Path
+    module_name: str,
+    level: int,
+    source_rel: str,
+    root_path: Path,
+    path_index: Optional[set[str]] = None,
 ) -> Optional[str]:
     parts = Path(source_rel).parts
     if level > len(parts):
@@ -120,15 +133,21 @@ def _resolve_relative_import(
     extensions = [".py", ".pyw"]
     for ext in extensions:
         candidate = f"{base}{ext}"
-        if _exists_in_project(candidate, root_path):
+        if _exists_in_project(candidate, root_path, path_index):
             return candidate
         init_candidate = f"{base}/__init__{ext}"
-        if _exists_in_project(init_candidate, root_path):
+        if _exists_in_project(init_candidate, root_path, path_index):
             return init_candidate
     return None
 
 
-def _exists_in_project(candidate_path: str, root_path: Path) -> bool:
+def _exists_in_project(
+    candidate_path: str,
+    root_path: Path,
+    path_index: Optional[set[str]] = None,
+) -> bool:
+    if path_index is not None:
+        return candidate_path in path_index
     full = root_path / candidate_path
     return full.exists()
 

ctxgraph_code/analyzers/python/semantic.py

@@ -2,19 +2,27 @@ from __future__ import annotations
 
 import ast
 from pathlib import Path
+from typing import Optional
 
 from ctxgraph_code.graph.models import Node
 
 
-def enrich_node_summary(node: Node, file_path: Path) -> str:
+def enrich_node_summary(
+    node: Node,
+    file_path: Path,
+    *,
+    source: Optional[str] = None,
+    tree: Optional[ast.AST] = None,
+) -> str:
     if node.summary:
         return node.summary
 
-    try:
-        source = file_path.read_text(encoding="utf-8", errors="replace")
-        tree = ast.parse(source)
-    except (SyntaxError, FileNotFoundError):
-        return node.summary or ""
+    if tree is None:
+        try:
+            source = file_path.read_text(encoding="utf-8", errors="replace")
+            tree = ast.parse(source)
+        except (SyntaxError, FileNotFoundError):
+            return node.summary or ""
 
     if node.type == "file":
         return _summarize_file(tree, file_path)

ctxgraph_code/analyzers/python/symbols.py

@@ -4,36 +4,56 @@ import ast
 from pathlib import Path
 from typing import Optional
 
-from ctxgraph_code.graph.models import Edge, Graph, Node
+from ctxgraph_code.graph.models import Graph
 
 
-def analyze_symbols(file_path: Path, root_path: Path) -> Graph:
-    graph = Graph()
+def analyze_symbols(
+    file_path: Path,
+    root_path: Path,
+    *,
+    source: Optional[str] = None,
+    tree: Optional[ast.AST] = None,
+) -> Graph:
     rel_path = _relative_path(file_path, root_path)
     file_node_id = f"file:{rel_path}"
 
-    try:
-        source = file_path.read_text(encoding="utf-8", errors="replace")
-        tree = ast.parse(source)
-    except SyntaxError:
-        return graph
+    if tree is None:
+        try:
+            source = file_path.read_text(encoding="utf-8", errors="replace")
+            tree = ast.parse(source)
+        except SyntaxError:
+            return Graph()
 
-    lines = source.split("\n")
+    lines = source.split("\n") if source else []
+    nodes: list[dict] = []
+    edges: list[dict] = []
 
     for node in ast.iter_child_nodes(tree):
         if isinstance(node, ast.ClassDef):
-            _process_class(node, graph, file_node_id, rel_path, lines)
+            _process_class(node, nodes, edges, file_node_id, rel_path, lines)
         elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            _process_function(node, graph, file_node_id, rel_path, lines)
+            _process_function(node, nodes, edges, file_node_id, rel_path, lines)
+
+    _process_calls(tree, nodes, edges, rel_path)
+
+    return Graph.from_batch(nodes, edges)
+
+
+# ── helpers ─────────────────────────────────────────────────────────────────
+
 
-    _process_calls(tree, graph, rel_path)
+def _node_dict(**kw) -> dict:
+    return dict(kw)
 
-    return graph
+
+def _edge_dict(**kw) -> dict:
+    return dict(kw)
 
 
 def _process_class(
     node: ast.ClassDef,
-    graph: Graph,
+    nodes: list[dict],
+    edges: list[dict],
     file_node_id: str,
     rel_path: str,
     lines: list[str],
@@ -42,45 +62,40 @@ def _process_class(
     summary = _extract_docstring(node)
     bases = _get_base_names(node)
 
-    graph.add_node(
-        Node(
-            id=class_id,
-            type="class",
-            name=node.name,
-            path=rel_path,
-            parent_id=file_node_id,
-            summary=summary,
-            importance=0.6,
-            lineno=node.lineno,
-        )
-    )
-    graph.add_edge(
-        Edge(
-            source_id=file_node_id,
-            target_id=class_id,
-            relation="defines",
-            weight=1.0,
-        )
-    )
+    nodes.append(_node_dict(
+        id=class_id,
+        type="class",
+        name=node.name,
+        path=rel_path,
+        parent_id=file_node_id,
+        summary=summary,
+        importance=0.6,
+        lineno=node.lineno,
+    ))
+    edges.append(_edge_dict(
+        source_id=file_node_id,
+        target_id=class_id,
+        relation="defines",
+        weight=1.0,
+    ))
 
     for base in bases:
-        graph.add_edge(
-            Edge(
-                source_id=class_id,
-                target_id=base,
-                relation="extends",
-                weight=0.8,
-            )
-        )
+        edges.append(_edge_dict(
+            source_id=class_id,
+            target_id=base,
+            relation="extends",
+            weight=0.8,
+        ))
 
     for child in ast.iter_child_nodes(node):
         if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            _process_method(child, graph, class_id, rel_path, lines)
+            _process_method(child, nodes, edges, class_id, rel_path, lines)
 
 
 def _process_function(
     node: (ast.FunctionDef | ast.AsyncFunctionDef),
-    graph: Graph,
+    nodes: list[dict],
+    edges: list[dict],
     file_node_id: str,
     rel_path: str,
     lines: list[str],
@@ -88,31 +103,28 @@ def _process_function(
     func_id = f"func:{rel_path}::{node.name}"
     summary = _extract_docstring(node)
 
-    graph.add_node(
-        Node(
-            id=func_id,
-            type="function",
-            name=node.name,
-            path=rel_path,
-            parent_id=file_node_id,
-            summary=summary,
-            importance=0.5,
-            lineno=node.lineno,
-        )
-    )
-    graph.add_edge(
-        Edge(
-            source_id=file_node_id,
-            target_id=func_id,
-            relation="defines",
-            weight=1.0,
-        )
-    )
+    nodes.append(_node_dict(
+        id=func_id,
+        type="function",
+        name=node.name,
+        path=rel_path,
+        parent_id=file_node_id,
+        summary=summary,
+        importance=0.5,
+        lineno=node.lineno,
+    ))
+    edges.append(_edge_dict(
+        source_id=file_node_id,
+        target_id=func_id,
+        relation="defines",
+        weight=1.0,
+    ))
 
 
 def _process_method(
     node: (ast.FunctionDef | ast.AsyncFunctionDef),
-    graph: Graph,
+    nodes: list[dict],
+    edges: list[dict],
     class_id: str,
     rel_path: str,
     lines: list[str],
@@ -120,45 +132,39 @@ def _process_method(
     method_id = f"func:{rel_path}::{node.name}"
     summary = _extract_docstring(node)
 
-    graph.add_node(
-        Node(
-            id=method_id,
-            type="function",
-            name=node.name,
-            path=rel_path,
-            parent_id=class_id,
-            summary=summary,
-            importance=0.5,
-            lineno=node.lineno,
-        )
-    )
-    graph.add_edge(
-        Edge(
-            source_id=class_id,
-            target_id=method_id,
-            relation="defines",
-            weight=1.0,
-        )
-    )
-
-
-def _process_calls(tree: ast.AST, graph: Graph, rel_path: str):
+    nodes.append(_node_dict(
+        id=method_id,
+        type="function",
+        name=node.name,
+        path=rel_path,
+        parent_id=class_id,
+        summary=summary,
+        importance=0.5,
+        lineno=node.lineno,
+    ))
+    edges.append(_edge_dict(
+        source_id=class_id,
+        target_id=method_id,
+        relation="defines",
+        weight=1.0,
+    ))
+
+
+def _process_calls(tree: ast.AST, nodes: list[dict], edges: list[dict], rel_path: str):
     for node in ast.walk(tree):
         if isinstance(node, ast.Call):
             func_name = _get_call_name(node.func)
             if func_name:
                 caller_id = _find_enclosing_symbol(tree, node, rel_path)
                 if caller_id:
-                    callee_node = _find_target_node(func_name, graph)
-                    if callee_node:
-                        graph.add_edge(
-                            Edge(
-                                source_id=caller_id,
-                                target_id=callee_node.id,
-                                relation="calls",
-                                weight=0.7,
-                            )
-                        )
+                    callee_id = _find_target_node(func_name, nodes)
+                    if callee_id:
+                        edges.append(_edge_dict(
+                            source_id=caller_id,
+                            target_id=callee_id,
+                            relation="calls",
+                            weight=0.7,
+                        ))
 
 
 def _get_call_name(node: ast.AST) -> Optional[str]:
@@ -191,10 +197,10 @@ def _contains_node(container: ast.AST, target: ast.AST) -> bool:
     return False
 
 
-def _find_target_node(name: str, graph: Graph) -> Optional[Node]:
-    for node in graph.nodes.values():
-        if node.type in ("function", "class") and node.name == name:
-            return node
+def _find_target_node(name: str, nodes: list[dict]) -> Optional[str]:
+    for nd in nodes:
+        if nd.get("type") in ("function", "class") and nd["name"] == name:
+            return nd["id"]
     return None