codeanalyzer-python 1.3.0__tar.gz → 1.4.0__tar.gz

{codeanalyzer_python-1.3.0 → codeanalyzer_python-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codeanalyzer-python
-Version: 1.3.0
+Version: 1.4.0
 Summary: Static analysis for Python — canonical schema v2 (symbol table, call graph, and native CFG/PDG/SDG dataflow) as analysis.json or a Neo4j property graph.
 Author-email: Rahul Krishna <i.m.ralk@gmail.com>
 License-File: LICENSE
@@ -99,7 +99,9 @@ needs.
   **interprocedural SDG** (synthetic parameter vertices, `param_in`/`param_out`/`summary`,
   alias-aware DDG) at level 4 — all built in-process from the stdlib `ast`.
 - **Neo4j output** — project the analysis into a labeled property graph: a self-contained
-  `graph.cypher` snapshot, or an **incremental** push to a live database over Bolt.
+  `graph.cypher` snapshot, or an **incremental** push to a live database over Bolt. A push is
+  **additive by default** and never deletes: `--eager` is what permits it to remove declarations
+  and edges the source no longer has.
 - **Versioned schema** — a machine-readable, version-stamped Neo4j schema contract (`--emit schema`),
   checked in as `schema.neo4j.json` (`2.0.0`) and shipped with every release.
 - **Incremental cache** — per-file results are cached under `.codeanalyzer`; `--lazy` (default)
@@ -300,7 +302,19 @@ $ canpy --help
 │ --eager                --lazy                               Enable eager or  │
 │                                                             lazy analysis.   │
 │                                                             Defaults to      │
-│                                                             lazy.            │
+│                                                             lazy. Also gates │
+│                                                             every            │
+│                                                             destructive step │
+│                                                             of a '--emit     │
+│                                                             neo4j' Bolt      │
+│                                                             push: a lazy     │
+│                                                             push only adds   │
+│                                                             and updates, an  │
+│                                                             eager one also   │
+│                                                             removes          │
+│                                                             declarations and │
+│                                                             edges the source │
+│                                                             no longer has.   │
 │                                                             [default: lazy]  │
 │ --skip-tests           --include-tests                      Skip test files  │
 │                                                             in analysis.     │
@@ -361,26 +375,18 @@ $ canpy --help
 │                                                             `source` text on │
 │                                                             discovered       │
 │                                                             artifacts.       │
+│                                                             `source` is the  │
+│                                                             whole file;      │
 │                                                             --no-artifact-t… │
-│                                                             empties `source` │
+│                                                             empties it       │
 │                                                             everywhere       │
 │                                                             (inventory       │
 │                                                             unchanged).      │
-│                                                             [default:        │
-│                                                             artifact-text]   │
-│ --artifact-text-…                         <int range>       Per-file byte    │
-│                                           [x>=1]            cap on captured  │
-│                                                             artifact         │
-│                                                             `source`; a      │
-│                                                             decodable file   │
-│                                                             over the cap is  │
-│                                                             truncated        │
-│                                                             (text_truncated… │
 │                                                             sha256/size_byt… │
 │                                                             always reflect   │
 │                                                             the full file.   │
 │                                                             [default:        │
-│                                                             262144]          │
+│                                                             artifact-text]   │
 │ --help                                                      Show this        │
 │                                                             message and      │
 │                                                             exit.            │

{codeanalyzer_python-1.3.0 → codeanalyzer_python-1.4.0}/README.md

@@ -66,7 +66,9 @@ needs.
   **interprocedural SDG** (synthetic parameter vertices, `param_in`/`param_out`/`summary`,
   alias-aware DDG) at level 4 — all built in-process from the stdlib `ast`.
 - **Neo4j output** — project the analysis into a labeled property graph: a self-contained
-  `graph.cypher` snapshot, or an **incremental** push to a live database over Bolt.
+  `graph.cypher` snapshot, or an **incremental** push to a live database over Bolt. A push is
+  **additive by default** and never deletes: `--eager` is what permits it to remove declarations
+  and edges the source no longer has.
 - **Versioned schema** — a machine-readable, version-stamped Neo4j schema contract (`--emit schema`),
   checked in as `schema.neo4j.json` (`2.0.0`) and shipped with every release.
 - **Incremental cache** — per-file results are cached under `.codeanalyzer`; `--lazy` (default)
@@ -267,7 +269,19 @@ $ canpy --help
 │ --eager                --lazy                               Enable eager or  │
 │                                                             lazy analysis.   │
 │                                                             Defaults to      │
-│                                                             lazy.            │
+│                                                             lazy. Also gates │
+│                                                             every            │
+│                                                             destructive step │
+│                                                             of a '--emit     │
+│                                                             neo4j' Bolt      │
+│                                                             push: a lazy     │
+│                                                             push only adds   │
+│                                                             and updates, an  │
+│                                                             eager one also   │
+│                                                             removes          │
+│                                                             declarations and │
+│                                                             edges the source │
+│                                                             no longer has.   │
 │                                                             [default: lazy]  │
 │ --skip-tests           --include-tests                      Skip test files  │
 │                                                             in analysis.     │
@@ -328,26 +342,18 @@ $ canpy --help
 │                                                             `source` text on │
 │                                                             discovered       │
 │                                                             artifacts.       │
+│                                                             `source` is the  │
+│                                                             whole file;      │
 │                                                             --no-artifact-t… │
-│                                                             empties `source` │
+│                                                             empties it       │
 │                                                             everywhere       │
 │                                                             (inventory       │
 │                                                             unchanged).      │
-│                                                             [default:        │
-│                                                             artifact-text]   │
-│ --artifact-text-…                         <int range>       Per-file byte    │
-│                                           [x>=1]            cap on captured  │
-│                                                             artifact         │
-│                                                             `source`; a      │
-│                                                             decodable file   │
-│                                                             over the cap is  │
-│                                                             truncated        │
-│                                                             (text_truncated… │
 │                                                             sha256/size_byt… │
 │                                                             always reflect   │
 │                                                             the full file.   │
 │                                                             [default:        │
-│                                                             262144]          │
+│                                                             artifact-text]   │
 │ --help                                                      Show this        │
 │                                                             message and      │
 │                                                             exit.            │

{codeanalyzer_python-1.3.0 → codeanalyzer_python-1.4.0}/codeanalyzer/__main__.py

@@ -175,7 +175,10 @@ def main(
         bool,
         typer.Option(
             "--eager/--lazy",
-            help="Enable eager or lazy analysis. Defaults to lazy.",
+            help="Enable eager or lazy analysis. Defaults to lazy. Also gates every "
+            "destructive step of a '--emit neo4j' Bolt push: a lazy push only adds and "
+            "updates, an eager one also removes declarations and edges the source no "
+            "longer has.",
         ),
     ] = False,
     skip_tests: Annotated[
@@ -239,19 +242,11 @@ def main(
         typer.Option(
             "--artifact-text/--no-artifact-text",
             help="Capture verbatim `source` text on discovered artifacts. "
-            "--no-artifact-text empties `source` everywhere (inventory unchanged).",
+            "`source` is the whole file; --no-artifact-text empties it "
+            "everywhere (inventory unchanged). sha256/size_bytes always "
+            "reflect the full file.",
         ),
     ] = True,
-    artifact_text_max_bytes: Annotated[
-        int,
-        typer.Option(
-            "--artifact-text-max-bytes",
-            help="Per-file byte cap on captured artifact `source`; a decodable "
-            "file over the cap is truncated (text_truncated=True). "
-            "sha256/size_bytes always reflect the full file.",
-            min=1,
-        ),
-    ] = 262144,
 ):
     # Determinism: pin the interpreter hash seed before any analysis (no-op
     # when PYTHONHASHSEED is already set; --version exits before this).
@@ -336,7 +331,6 @@ def main(
         verbosity=verbosity,
         entrypoint_rules=tuple(entrypoint_rules or ()),
         artifact_text=artifact_text,
-        artifact_text_max_bytes=artifact_text_max_bytes,
     )
 
     _set_log_level(options.verbosity)

{codeanalyzer_python-1.3.0 → codeanalyzer_python-1.4.0}/codeanalyzer/artifacts/dependencies.py

@@ -81,9 +81,9 @@ def _resolve_ref(manifest_path: str, ref: str) -> Optional[str]:
 
 def _full_text(project_dir: Path, path: str, art: PyArtifact) -> str:
     """Manifest/lock extraction must never depend on the stored ``source`` --
-    that's capped by ``text_max_bytes`` and emptied by ``capture_text=False``
-    (both payload-size controls on the JSON/Neo4j payload, not extraction
-    controls). Read the real file fresh instead; fall back to ``art.source``
+    that's emptied by ``capture_text=False`` (a payload-size control on the
+    JSON/Neo4j payload, not an extraction control). Read the real file fresh
+    instead; fall back to ``art.source``
     only if it is gone (e.g. a synthetic artifact in a unit test, or the file
     vanished mid-run).
 

{codeanalyzer_python-1.3.0 → codeanalyzer_python-1.4.0}/codeanalyzer/artifacts/discovery.py

@@ -76,27 +76,11 @@ def _classify(rel_posix: str) -> Tuple[str, List[str]] | None:
     return None
 
 
-def _capture_source(
-    raw: bytes, text: str, capture_text: bool, text_max_bytes: int
-) -> Tuple[str, bool]:
-    """Decide ``(source, text_truncated)`` for a decodable file.
-
-    Slices ``raw`` (not ``text``) for the cap, so it is a true byte cap even
-    when it lands inside a multi-byte character -- ``errors="ignore"`` drops
-    the dangling partial char at the cut, so this never raises."""
-    if not capture_text:
-        return "", False
-    if len(raw) <= text_max_bytes:
-        return text, False
-    return raw[:text_max_bytes].decode("utf-8", errors="ignore"), True
-
-
 def discover_artifacts(
     project_dir: Path,
     app_name: str,
     *,
     capture_text: bool = True,
-    text_max_bytes: int = 262144,
 ) -> Dict[str, PyArtifact]:
     """Walk the project and return every file as an artifact, sorted by path.
 
@@ -109,15 +93,11 @@ def discover_artifacts(
     deliberate exception -- it IS rule-matched (a dependency-manifest), so it
     is captured like any other manifest despite the `.py` suffix.
 
-    ``capture_text=False`` empties ``source`` everywhere (inventory otherwise
-    identical); a decodable file over ``text_max_bytes`` gets a truncated
-    ``source`` and ``text_truncated=True`` -- except a ``dependency-manifest``
-    role artifact, which is always captured in full when decodable and
-    ``capture_text`` is on: its source is what ``build_dependency_view``
-    parses, not bulk/incidental content, so the byte cap does not apply to
-    it (``capture_text=False`` still empties it like everything else).
-    ``sha256``/``size_bytes`` always reflect the full file regardless of
-    either knob."""
+    ``source`` is the WHOLE file or nothing -- never a prefix (#172). A
+    decodable file is captured in full; ``capture_text=False`` empties
+    ``source`` everywhere (inventory otherwise identical), and an undecodable
+    file gets ``""`` as ``binary``. ``sha256``/``size_bytes`` always reflect
+    the full file regardless."""
     out: Dict[str, PyArtifact] = {}
     for path in sorted(project_dir.rglob("*")):
         if not path.is_file():
@@ -148,20 +128,14 @@ def discover_artifacts(
             if decodable and "." not in name and text.startswith("#!"):
                 roles = ["script"]
         if decodable:
-            # A dependency-manifest's source IS the extracted meaning (build_
-            # dependency_view parses it) -- the byte cap targets bulk/incidental
-            # assets, never the files extraction depends on, so manifests are
-            # exempt from it. capture_text=False still empties source (handled
-            # inside _capture_source); only the byte CAP is bypassed here.
-            cap = len(raw) if "dependency-manifest" in roles else text_max_bytes
-            source, text_truncated = _capture_source(raw, text, capture_text, cap)
+            source = text if capture_text else ""
         else:
-            fmt, source, text_truncated = "binary", "", False
+            fmt, source = "binary", ""
 
         out[rel_posix] = PyArtifact(
             id=artifact_id(app_name, rel_posix), path=rel_posix, format=fmt,
             roles=list(roles), size_bytes=len(raw),
             sha256=hashlib.sha256(raw).hexdigest(),
-            source=source, text_truncated=text_truncated,
+            source=source,
         )
     return out

{codeanalyzer_python-1.3.0 → codeanalyzer_python-1.4.0}/codeanalyzer/core.py

@@ -40,9 +40,9 @@ from codeanalyzer.provenance import analyzer_info, repository_info
 def _artifact_full_text(project_dir: Path, path: str, art) -> str:
     """Mirrors ``artifacts.dependencies._full_text`` verbatim (not imported
     -- that name is module-private to ``dependencies.py``): config-key
-    extraction (#152) must never depend on the stored ``source`` -- capped
-    by ``text_max_bytes`` and emptied by ``capture_text=False`` (payload-size
-    controls, not extraction controls). Read the real file fresh instead;
+    extraction (#152) must never depend on the stored ``source`` -- emptied
+    by ``capture_text=False`` (a payload-size control, not an extraction
+    control). Read the real file fresh instead;
     fall back to ``art.source`` only if it's gone (e.g. a synthetic artifact
     in a unit test, or the file vanished mid-run). Keep the two in sync if
     this logic changes."""
@@ -673,7 +673,6 @@ class Codeanalyzer:
         app.artifacts = discover_artifacts(
             self.project_dir, app_name,
             capture_text=self.options.artifact_text,
-            text_max_bytes=self.options.artifact_text_max_bytes,
         )
         app.dependencies, app.unresolved_imports = build_dependency_view(
             app.artifacts,

{codeanalyzer_python-1.3.0 → codeanalyzer_python-1.4.0}/codeanalyzer/dataflow/builder.py

@@ -442,8 +442,13 @@ def build_program_graphs(
             for t in cs.targets:
                 call_edges.append((sig, t))
 
-    summaries = compute_summaries(infos, sorted(set(call_edges)))
-    return assemble_sdg(infos, summaries, k)
+    # The converged (facts, ddg) per function are threaded straight into the
+    # assembler rather than re-derived there (#155).
+    solutions: Dict[str, object] = {}
+    summaries = compute_summaries(
+        infos, sorted(set(call_edges)), solutions=solutions
+    )
+    return assemble_sdg(infos, summaries, k, solutions=solutions)
 
 
 def emit_l4(

{codeanalyzer_python-1.3.0 → codeanalyzer_python-1.4.0}/codeanalyzer/dataflow/sdg.py

@@ -386,8 +386,18 @@ def assemble_sdg(
     infos: Dict[str, FunctionInfo],
     summaries: Dict[str, FunctionSummary],
     k: int,
+    *,
+    solutions: Optional[Dict[str, Tuple[Dict[int, object], List[object]]]] = None,
 ) -> ProgramGraphsIR:
-    """Stitch every function's PDG into the whole-program SDG."""
+    """Stitch every function's PDG into the whole-program SDG.
+
+    *solutions* optionally carries the converged ``(facts, ddg)`` that
+    :func:`~codeanalyzer.dataflow.summaries.compute_summaries` already
+    derived, sparing a second identical solve per function (#155). Omit it and
+    every function is re-solved, which is the historical behaviour and the
+    right posture whenever *summaries* did not come from an immediately
+    preceding run over these same *infos*.
+    """
     ir = ProgramGraphsIR(k_limit=k)
 
     # Pass 1: solve each function against the final summaries and lay out its
@@ -396,7 +406,12 @@ def assemble_sdg(
     formal_ids: Dict[str, Dict[str, int]] = {}
     for sig in sorted(infos):
         info = infos[sig]
-        summary, facts, ddg = solve_function(info, summaries)
+        cached = solutions.get(sig) if solutions is not None else None
+        if cached is None:
+            summary, facts, ddg = solve_function(info, summaries)
+        else:
+            facts, ddg = cached
+            summary = summaries[sig]
         asm = _FunctionAssembler(info, summary, facts, ddg)
         asm.build_formals()
         assemblers[sig] = asm

{codeanalyzer_python-1.3.0 → codeanalyzer_python-1.4.0}/codeanalyzer/dataflow/summaries.py

@@ -199,19 +199,42 @@ def solve_function(
 def compute_summaries(
     infos: Dict[str, FunctionInfo],
     call_edges: List[Tuple[str, str]],
+    *,
+    solutions: Optional[Dict[str, Tuple[Dict[int, object], List[DDGEdge]]]] = None,
 ) -> Dict[str, FunctionSummary]:
     """Bottom-up composition over the SCC condensation DAG, monotone fixpoint
-    within each SCC."""
+    within each SCC.
+
+    A **singleton SCC with no self-edge** is solved exactly once: the
+    condensation is processed bottom-up, so every callee summary it reads is
+    already final and a second pass could only recompute the same answer to
+    observe that nothing changed. Genuinely recursive SCCs (several members,
+    or one member calling itself) still iterate to fixpoint.
+
+    When *solutions* is supplied it receives each signature's converged
+    ``(facts, ddg)`` — the by-products of the final solve, which
+    :func:`~codeanalyzer.dataflow.sdg.assemble_sdg` would otherwise recompute
+    from scratch. They are the same values that a fresh solve against the
+    final summaries produces, because a converged pass is by definition one
+    in which no member's summary changed (#155).
+    """
     order = strongly_connected_components(sorted(infos), call_edges)
+    self_calls = {src for src, dst in call_edges if src == dst}
     summaries: Dict[str, FunctionSummary] = {}
     for scc in order:
         members = [s for s in scc if s in infos]
-        changed = True
-        while changed:
+        if not members:
+            continue
+        recursive = len(members) > 1 or members[0] in self_calls
+        while True:
             changed = False
             for sig in members:
-                new, _, _ = solve_function(infos[sig], summaries)
+                new, facts, ddg = solve_function(infos[sig], summaries)
+                if solutions is not None:
+                    solutions[sig] = (facts, ddg)
                 if summaries.get(sig) != new:
                     summaries[sig] = new
                     changed = True
+            if not (recursive and changed):
+                break
     return summaries

{codeanalyzer_python-1.3.0 → codeanalyzer_python-1.4.0}/codeanalyzer/neo4j/bolt.py

@@ -27,11 +27,24 @@ Algorithm (the module subgraph is the unit of idempotent replacement):
   4. upsert edges owned by changed modules (+ the shared edges).
   5. on a FULL run only, prune modules whose source file vanished.
 
+**A push never deletes by default** (#171). Steps 3 and 5 are the only destructive
+ones and both run on ``eager`` (``--eager``) only; a default ``--lazy`` push is purely
+additive — MERGE-upsert of nodes and edges, nothing removed. The cost of the default is
+staleness: a declaration or a call edge the source no longer has stays in the graph until
+an ``--eager`` push reconciles it. That is the deliberate trade — an incremental push into
+a shared database should not be able to destroy anything, and the destructive rebuild is
+opt-in under the same flag that already forces a clean analysis rebuild.
+
 Nodes are MERGE-upserted, never blindly deleted, so a declaration another
 (unchanged) module still references survives and its incoming edges stay valid.
 ``:PyExternal`` / ``:PyPackage`` / ``:PyDecorator`` are shared (no ``_module``) and are
 MERGE-only.
 
+Every ``_module`` match is anchored on the python-owned labels
+(``schema.MODULE_OWNED_PATTERN``). ``_module`` is a shared convention, not a python-private
+one -- codeanalyzer-java and codeanalyzer-typescript set it on their nodes too -- so an
+unlabelled match reaches a sibling analyzer's graph in a shared database (#171).
+
 The ``neo4j`` driver is imported lazily so it stays an optional dependency and
 off the default (json) output path entirely.
 """
@@ -41,7 +54,7 @@ from dataclasses import dataclass
 from typing import Dict, List, Optional
 
 from codeanalyzer.neo4j.rows import EdgeRow, GraphRows, NodeRow, chunk
-from codeanalyzer.neo4j.schema import CONSTRAINTS, INDEXES
+from codeanalyzer.neo4j.schema import CONSTRAINTS, INDEXES, MODULE_OWNED_PATTERN
 from codeanalyzer.utils import logger
 
 DESCENDANTS = (
@@ -59,7 +72,7 @@ class BoltConfig:
     database: Optional[str] = None
 
 
-def bolt_writer(rows: GraphRows, cfg: BoltConfig, full_run: bool) -> None:
+def bolt_writer(rows: GraphRows, cfg: BoltConfig, full_run: bool, eager: bool = False) -> None:
     try:
         import neo4j  # noqa: WPS433 (lazy, optional dependency)
     except ImportError as exc:  # pragma: no cover - exercised only without the extra
@@ -119,15 +132,26 @@ def bolt_writer(rows: GraphRows, cfg: BoltConfig, full_run: bool) -> None:
         _upsert_nodes(session, neo4j, shared)
 
         # 4. per changed module: purge owned edges + vanished decls, then upsert its nodes.
+        # The purge is the only destructive step in a push, so it runs on --eager only.
         for m in changed:
             nodes = by_module[m]
             keys = [n.value for n in nodes]
+            if not eager:
+                _upsert_nodes(session, neo4j, nodes)
+                continue
             with session() as s:
                 def _purge(tx, module=m, node_keys=keys):
-                    tx.run("MATCH (x {_module: $m})-[r]->() DELETE r", m=module)
+                    # Anchored on python-owned labels: `_module` is also set by the java
+                    # and typescript analyzers, so an unlabelled match would delete a
+                    # sibling's nodes wherever a file key collides (#171).
                     tx.run(
-                        "MATCH (x {_module: $m}) "
-                        "WHERE NOT coalesce(x.signature, x.id, x.file_key) IN $keys "
+                        f"MATCH (x:{MODULE_OWNED_PATTERN}) WHERE x._module = $m "
+                        "MATCH (x)-[r]->() DELETE r",
+                        m=module,
+                    )
+                    tx.run(
+                        f"MATCH (x:{MODULE_OWNED_PATTERN}) WHERE x._module = $m "
+                        "AND NOT coalesce(x.signature, x.id, x.file_key) IN $keys "
                         "DETACH DELETE x",
                         m=module,
                         keys=node_keys,
@@ -147,7 +171,7 @@ def bolt_writer(rows: GraphRows, cfg: BoltConfig, full_run: bool) -> None:
         # 6. orphan prune — only safe on a full run (a targeted run can't tell deleted from untargeted).
         # Scope to THIS application's anchor so a full run for application B never
         # deletes application A's modules from a shared database.
-        if full_run and app_name is not None:
+        if full_run and eager and app_name is not None:
             present = list(by_module.keys())
             with session() as s:
                 res = s.run(
@@ -161,6 +185,11 @@ def bolt_writer(rows: GraphRows, cfg: BoltConfig, full_run: bool) -> None:
                 pruned = res.single()
                 pruned_count = pruned["pruned"] if pruned else 0
                 logger.info(f"neo4j(bolt): pruned {pruned_count} vanished module(s)")
+        elif not eager:
+            logger.info(
+                "neo4j(bolt): additive push (--lazy) — nothing deleted; "
+                "re-run with --eager to reconcile removed declarations and edges"
+            )
         else:
             logger.info(
                 "neo4j(bolt): targeted run — orphan pruning skipped (deleted files not removed)"

{codeanalyzer_python-1.3.0 → codeanalyzer_python-1.4.0}/codeanalyzer/neo4j/emit.py

@@ -67,9 +67,10 @@ def emit_neo4j(analysis: Analysis, options: AnalysisOptions) -> None:
             password=options.neo4j_password,
             database=options.neo4j_database,
         )
-        # A full run (no single-file restriction) makes orphan pruning safe.
+        # A full run (no single-file restriction) makes orphan pruning safe; --eager
+        # is what permits any deletion at all (#171).
         full_run = options.file_name is None
-        bolt_writer(rows, cfg, full_run)
+        bolt_writer(rows, cfg, full_run, eager=options.rebuild_analysis)
         return
 
     out_dir = options.output if options.output is not None else Path.cwd()

{codeanalyzer_python-1.3.0 → codeanalyzer_python-1.4.0}/codeanalyzer/neo4j/project.py

@@ -309,7 +309,6 @@ def _project_artifacts(b: RowBuilder, app: PyApplication, app_name: str, app_ref
                     "size_bytes": art.size_bytes,
                     "sha256": art.sha256,
                     "source": art.source,
-                    "text_truncated": art.text_truncated,
                     "extraction": art.extraction,
                 }
             ),

{codeanalyzer_python-1.3.0 → codeanalyzer_python-1.4.0}/codeanalyzer/neo4j/schema.py

@@ -210,7 +210,7 @@ NODE_LABELS: List[NodeLabel] = [
     NodeLabel("Artifact", "Artifact", "id", {
         "id": "string", "path": "string", "format": "string",
         "roles": "string[]", "size_bytes": "integer", "sha256": "string",
-        "source": "string", "text_truncated": "boolean", "extraction": "string",
+        "source": "string", "extraction": "string",
     }),
     NodeLabel("Package", "Package", "id", {
         "id": "string", "ecosystem": "string", "name": "string",
@@ -332,10 +332,27 @@ def uniqueness_constraints() -> list[str]:
 
 CONSTRAINTS: List[str] = uniqueness_constraints()
 
+# The labels this analyzer owns per module -- the ones carrying the internal ``_module``
+# provenance property. Derived from NODE_LABELS so a new module-scoped label is covered
+# without a second list to maintain. `_module` is NOT python-private: codeanalyzer-java
+# and codeanalyzer-typescript set the same property on their nodes, so every statement
+# matching on it must be anchored to these labels or it matches a sibling analyzer's graph
+# in a shared database (#171).
+MODULE_OWNED_LABELS: List[str] = [n.label for n in NODE_LABELS if "_module" in n.properties]
+
+# The label disjunction to anchor such a statement with: ``MATCH (x:PyModule|PyClass|...)``.
+MODULE_OWNED_PATTERN: str = "|".join(MODULE_OWNED_LABELS)
+
 INDEXES: List[str] = [
     "CREATE INDEX py_callable_name IF NOT EXISTS FOR (c:PyCallable) ON (c.name)",
     "CREATE INDEX py_class_name IF NOT EXISTS FOR (c:PyClass) ON (c.name)",
     "CREATE FULLTEXT INDEX py_code_fts IF NOT EXISTS FOR (c:PyCallable) ON EACH [c.code, c.docstring]",
+] + [
+    # One per module-owned label: the incremental writer's per-module purge matches on
+    # `_module` once per changed module, which without these is a label scan per label per
+    # module -- quadratic on a full push (#171).
+    f"CREATE INDEX {label.lower()}_module IF NOT EXISTS FOR (x:{label}) ON (x._module)"
+    for label in MODULE_OWNED_LABELS
 ]
 
 

{codeanalyzer_python-1.3.0 → codeanalyzer_python-1.4.0}/codeanalyzer/options/options.py

@@ -43,7 +43,6 @@ class AnalysisOptions:
     clear_cache: bool = False
     verbosity: int = 0
     entrypoint_rules: Tuple[Path, ...] = ()
-    # Artifact text-capture controls (#157 follow-up): whether to capture
-    # `source` at all, and the per-file byte cap before it truncates.
+    # Artifact text capture (#157 follow-up): whether to capture `source` at
+    # all. There is no byte cap -- `source` is the whole file or "" (#172).
     artifact_text: bool = True
-    artifact_text_max_bytes: int = 262144

{codeanalyzer_python-1.3.0 → codeanalyzer_python-1.4.0}/codeanalyzer/schema/py_schema.py

@@ -512,9 +512,8 @@ class PyArtifact(BaseModel):
     format: str  # toml|yaml|json|ini|properties|requirements|dockerfile|text|binary
     roles: List[str] = []
     size_bytes: int = 0
-    sha256: str = ""  # always the full file's hash, even when source is truncated/empty
-    source: str = ""  # verbatim by default; "" for binary or when capture is disabled
-    text_truncated: bool = False  # True when `source` is a prefix, not the full file
+    sha256: str = ""  # always the full file's hash, even when source is empty
+    source: str = ""  # the WHOLE file, or "" for binary / when capture is disabled -- never a prefix
     extraction: str = "none"  # none|partial|full
     config_keys: List[PyConfigKey] = []  # flattened config keys (#152); [] when not namespace-eligible
 

{codeanalyzer_python-1.3.0 → codeanalyzer_python-1.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codeanalyzer-python"
-version = "1.3.0"
+version = "1.4.0"
 description = "Static analysis for Python — canonical schema v2 (symbol table, call graph, and native CFG/PDG/SDG dataflow) as analysis.json or a Neo4j property graph."
 readme = "README.md"
 authors = [

{codeanalyzer_python-1.3.0 → codeanalyzer_python-1.4.0}/schema.neo4j.json

@@ -164,7 +164,6 @@
         "size_bytes": "integer",
         "sha256": "string",
         "source": "string",
-        "text_truncated": "boolean",
         "extraction": "string"
       }
     },
@@ -510,6 +509,12 @@
   "indexes": [
     "CREATE INDEX py_callable_name IF NOT EXISTS FOR (c:PyCallable) ON (c.name)",
     "CREATE INDEX py_class_name IF NOT EXISTS FOR (c:PyClass) ON (c.name)",
-    "CREATE FULLTEXT INDEX py_code_fts IF NOT EXISTS FOR (c:PyCallable) ON EACH [c.code, c.docstring]"
+    "CREATE FULLTEXT INDEX py_code_fts IF NOT EXISTS FOR (c:PyCallable) ON EACH [c.code, c.docstring]",
+    "CREATE INDEX pymodule_module IF NOT EXISTS FOR (x:PyModule) ON (x._module)",
+    "CREATE INDEX pyclass_module IF NOT EXISTS FOR (x:PyClass) ON (x._module)",
+    "CREATE INDEX pycallable_module IF NOT EXISTS FOR (x:PyCallable) ON (x._module)",
+    "CREATE INDEX pyattribute_module IF NOT EXISTS FOR (x:PyAttribute) ON (x._module)",
+    "CREATE INDEX pyvariable_module IF NOT EXISTS FOR (x:PyVariable) ON (x._module)",
+    "CREATE INDEX pybodynode_module IF NOT EXISTS FOR (x:PyBodyNode) ON (x._module)"
   ]
 }