codeanalyzer-python 1.5.3__py3-none-any.whl → 1.6.0__py3-none-any.whl

codeanalyzer/__main__.py

@@ -406,11 +406,10 @@ def _write_output(artifacts, output_dir: Path):
     # Use Pydantic's model_dump_json() for compact output
     # Strip internal-only fields here rather than with a field-level Pydantic
     # `exclude`: the analysis cache shares the serializer and must keep them.
-    json_str = json.dumps(
-        strip_internal_only(model_dump(artifacts, mode="json", exclude_none=True))
-    )
+    from codeanalyzer.core import stream_analysis_json, _log_mem  # LOW-MEM PATCH
     with output_file.open("w") as f:
-        f.write(json_str)
+        stream_analysis_json(artifacts, f, strip_internal=True)
+    _log_mem("after analysis.json write")
     logger.info(f"Analysis saved to {output_file}")
 
 

codeanalyzer/artifacts/config_keys.py

@@ -58,14 +58,9 @@ from __future__ import annotations
 import configparser
 import json
 import re
-import sys
+import tomllib
 from typing import Callable, Dict, List, Optional, Tuple
 
-if sys.version_info >= (3, 11):
-    import tomllib
-else:  # pragma: no cover - exercised on the 3.10 CI leg
-    import tomli as tomllib
-
 import yaml
 
 from codeanalyzer.schema.ids import config_key_id

codeanalyzer/artifacts/parsers.py

@@ -4,15 +4,10 @@ import ast
 import configparser
 import json
 import re
-import sys
+import tomllib
 from dataclasses import dataclass
 from typing import Dict, List, Optional, Tuple
 
-if sys.version_info >= (3, 11):
-    import tomllib
-else:  # pragma: no cover - exercised on the 3.10 CI leg
-    import tomli as tomllib
-
 import yaml
 
 

codeanalyzer/core.py

@@ -1,5 +1,8 @@
+import gc
 import hashlib
+import json
 import os
+import resource
 import shutil
 import subprocess
 import sys
@@ -53,6 +56,90 @@ def _artifact_full_text(project_dir: Path, path: str, art) -> str:
         return art.source
 
 
+def _log_mem(label: str) -> None:
+    """LOW-MEM PATCH: log current/peak RSS of the driver at phase boundaries."""
+    try:
+        cur = int(os.popen(f"ps -o rss= -p {os.getpid()}").read().strip() or 0) / 1024
+    except Exception:
+        cur = -1
+    peak = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+    peak = peak / (1024 * 1024) if sys.platform == "darwin" else peak / 1024  # bytes on macOS, KB on Linux
+    logger.info("[mem] %-40s rss=%6.0f MB peak=%6.0f MB", label, cur, peak)
+
+
+def stream_analysis_json(analysis, fh, *, strip_internal: bool) -> None:
+    """LOW-MEM PATCH: serialize an ``Analysis`` envelope to ``fh`` one module at a
+    time instead of materializing the whole tree as one JSON string (cache) or
+    as a dict tree + stripped copy + string (output). The JSON *content* equals
+    ``model_dump_json(exclude_none=True)`` / ``json.dumps(strip_internal_only(
+    model_dump(mode="json", exclude_none=True)))``; only whitespace differs
+    (compact separators throughout). ``call_sites`` live solely under the
+    symbol table's callables, so the envelope needs no stripping."""
+    from codeanalyzer.schema import strip_internal_only
+
+    from typing import List as _List
+    from pydantic import TypeAdapter
+    from codeanalyzer.schema.py_schema import ParamEdge, PyCallEdge
+
+    app = analysis.application
+    # Detach the big collections, dump the (now small) envelope, then splice
+    # each collection back in at its own slot, streaming it in chunks.
+    big = {
+        "symbol_table": (app.symbol_table, "{}"),
+        "call_graph": (app.call_graph, "[]"),
+        "param_in": (app.param_in, "[]"),
+        "param_out": (app.param_out, "[]"),
+    }
+    try:
+        app.symbol_table, app.call_graph, app.param_in, app.param_out = {}, [], [], []
+        envelope = analysis.model_dump_json(exclude_none=True)
+    finally:
+        app.symbol_table = big["symbol_table"][0]
+        app.call_graph = big["call_graph"][0]
+        app.param_in = big["param_in"][0]
+        app.param_out = big["param_out"][0]
+    slots = []
+    for name, (_value, empty) in big.items():
+        marker = f'"{name}":{empty}'
+        idx = envelope.find(marker)
+        if idx < 0 or envelope.find(marker, idx + 1) >= 0:
+            raise RuntimeError(f"stream_analysis_json: could not locate a unique {name} slot")
+        slots.append((idx + len(marker) - 1, name))  # position of the closing bracket
+    slots.sort()
+    adapters = {
+        "call_graph": TypeAdapter(_List[PyCallEdge]),
+        "param_in": TypeAdapter(_List[ParamEdge]),
+        "param_out": TypeAdapter(_List[ParamEdge]),
+    }
+    CHUNK = 20000
+    pos = 0
+    for cut, name in slots:
+        fh.write(envelope[pos:cut])
+        pos = cut
+        value = big[name][0]
+        first = True
+        if name == "symbol_table":
+            for key, module in value.items():
+                if strip_internal:
+                    body = json.dumps(
+                        strip_internal_only(module.model_dump(mode="json", exclude_none=True)),
+                        separators=(",", ":"),
+                    )
+                else:
+                    body = module.model_dump_json(exclude_none=True)
+                fh.write(("" if first else ",") + json.dumps(key) + ":" + body)
+                first = False
+        else:
+            adapter = adapters[name]
+            for i in range(0, len(value), CHUNK):
+                chunk = adapter.dump_json(value[i:i + CHUNK], exclude_none=True).decode()
+                inner = chunk[1:-1]  # strip the chunk's own [ ]
+                if inner:
+                    fh.write(("" if first else ",") + inner)
+                    first = False
+    fh.write(envelope[pos:])
+
+
 def _ensure_ray() -> None:
     """Initialize Ray with the driver's pinned hash seed in the workers.
 
@@ -60,13 +147,23 @@ def _ensure_ray() -> None:
     interpreters, so Jedi inference in Ray workers would run with random
     set-iteration order and the emitted edges vary run to run (issue #99)."""
     if not ray.is_initialized():
-        ray.init(
+        # LOW-MEM PATCH: start a private local cluster with object spilling to
+        # disk disabled, a bounded object store, and an optional worker cap
+        # (CANPY_RAY_CPUS); shut down after the symbol-table phase so the idle
+        # workers release their memory before the single-process L2-L4 phases.
+        init_kwargs = dict(
             runtime_env={
                 "env_vars": {
                     "PYTHONHASHSEED": os.environ.get("PYTHONHASHSEED", "0")
                 }
             },
+            _system_config={"automatic_object_spilling_enabled": False},
+            object_store_memory=int(os.environ.get("CANPY_RAY_OBJECT_STORE", 1_000_000_000)),
+            include_dashboard=False,
         )
+        if os.environ.get("CANPY_RAY_CPUS"):
+            init_kwargs["num_cpus"] = int(os.environ["CANPY_RAY_CPUS"])
+        ray.init(**init_kwargs)
 
 
 @ray.remote
@@ -747,7 +844,16 @@ class Codeanalyzer:
                 k=self.options.graph_field_depth,
                 oracle_factory=lambda c, fast: SyntacticOracle(),
             )
+            del _func_asts  # LOW-MEM PATCH: unused at L3; drop the def-node ASTs now
             emit_l3_body(app, infos, sig_to_id, set(self.options.graphs.split(",")))
+            # LOW-MEM PATCH: L4 only needs the syntactic DDG *sets* (for the
+            # points-to delta), not the PDGs with their statement ASTs.
+            from codeanalyzer.dataflow.builder import syntactic_ddg_sets
+            syn_ddg_sets = syntactic_ddg_sets(app, infos, sig_to_id)
+            infos.clear()
+            del infos
+            gc.collect()
+            _log_mem("after L3 emit (L3 PDGs freed)")
 
         # L4: interprocedural dataflow (param vertices + summary + param_in/out)
         # layered on top of the L3 syntactic overlay (L3 ⊆ L4). Scalpel is the
@@ -772,7 +878,14 @@ class Codeanalyzer:
             # Semantic ddg delta: the alias-derived def-use edges the real
             # oracle adds beyond the L3 syntactic set, tagged prov=["points-to"].
             # ``infos`` are the syntactic (L3) PDGs from the >=3 block above.
-            emit_ddg_pointsto_delta(app, infos, ir, sig_to_id)
+            emit_ddg_pointsto_delta(app, syn_ddg_sets, ir, sig_to_id)
+            # LOW-MEM PATCH: the L3/L4 intermediates (per-function PDGs with their
+            # statement ASTs, SDG IR) are dead from here on; free them before the
+            # config tiers and serialization instead of at analyze() return.
+            del ir
+            del syn_ddg_sets
+            gc.collect()
+            _log_mem("after L4 emit (intermediates freed)")
 
         # config_use (#162) resolution: literal tier always runs at >= 2;
         # the dataflow tiers widen the set as substrate comes online -- intra
@@ -872,7 +985,8 @@ class Codeanalyzer:
         cache_file.parent.mkdir(parents=True, exist_ok=True)
 
         with cache_file.open('w') as f:
-            f.write(model_dump_json(analysis, indent=2))
+            stream_analysis_json(analysis, f, strip_internal=False)  # LOW-MEM PATCH
+        _log_mem("after cache save")
 
         logger.info(f"Analysis cached to {cache_file}")
 
@@ -1013,6 +1127,8 @@ class Codeanalyzer:
                         if result:
                             symbol_table.update(result)
                         progress.advance()
+                ray.shutdown()  # LOW-MEM PATCH: release the worker pool's memory
+                logger.info("Ray shut down after the symbol-table phase.")
         else:
             logger.info("Building symbol table serially.")
             symbol_table_builder = SymbolTableBuilder(self.project_dir, self.virtualenv)

codeanalyzer/dataflow/access_paths.py

@@ -126,7 +126,7 @@ class FunctionScope:
         return "global"  # unknown free name: a module/builtin binding
 
 
-@dataclass
+@dataclass(slots=True)  # LOW-MEM PATCH: slots
 class StatementFacts:
     """Defs and uses (k-limited access-path strings) of one CFG node."""
 

codeanalyzer/dataflow/builder.py

@@ -50,6 +50,14 @@ from codeanalyzer.utils import logger
 
 DEFAULT_K_LIMIT = 3
 
+# LOW-MEM PATCH: one shared provenance list per kind instead of a fresh
+# ``["ssa"]`` list object on each of the (tens of) millions of DDG edges. The
+# lists are never mutated; equality comparisons (``e.prov != [...]``) and JSON
+# serialization are unaffected.
+_PROV_SSA = ["ssa"]
+_PROV_REACHING_DEFS = ["reaching-defs"]
+_PROV_POINTS_TO = ["points-to"]
+
 
 def _walk_callables(
     module: PyModule,
@@ -339,7 +347,7 @@ def emit_l3_body(
                         src=im.local(e.source),
                         dst=im.local(e.target),
                         var=e.var,
-                        prov=["ssa"],
+                        prov=_PROV_SSA,
                     )
                     for e in pdg.edges
                     if e.type == "DDG"
@@ -442,6 +450,16 @@ def build_program_graphs(
                 if nested_sig in infos:
                     info.nested_defs.append((node.id, nested_sig))
 
+    # LOW-MEM PATCH: from here on (summary fixpoint, SDG assembly, L4 emit) no
+    # stage reads a statement's AST -- only CFG node ids/positions, facts and
+    # oracles. Drop the def-node map and the per-node AST references so the
+    # whole-program AST copy this pass parsed is collected before the two most
+    # memory-hungry stages run.
+    func_asts.clear()
+    for info in infos.values():
+        for node in info.pdg.cfg.nodes:
+            node.ast_node = None
+
     call_edges = [
         (e.src, e.dst)
         for e in app.call_graph
@@ -609,7 +627,7 @@ def emit_l4(
                 continue
             seen.add(key)
             rows.append(
-                DdgEdge(src=src, dst=dst, var=e.var, prov=["reaching-defs"])
+                DdgEdge(src=src, dst=dst, var=e.var, prov=_PROV_REACHING_DEFS)
             )
         rows.sort(key=lambda r: (r.src, r.dst, r.var or ""))
         pycallable.ddg.extend(rows)
@@ -629,9 +647,36 @@ def _ddg_local_set(im, pdg) -> Set[Tuple[str, str, Optional[str]]]:
     }
 
 
+def syntactic_ddg_sets(
+    app: PyApplication,
+    infos: Dict[str, FunctionInfo],
+    sig_to_id: Dict[str, str],
+) -> Dict[str, Set[Tuple[str, str, Optional[str]]]]:
+    """LOW-MEM PATCH: precompute, per signature, the L3 syntactic DDG set in the
+    exact form :func:`emit_ddg_pointsto_delta` derives from ``syntactic_infos``
+    (local ids are position-based, so an IdentityMap over the syntactic PDG
+    yields the same locals as one over the L4 PDG). Lets the caller free the L3
+    ``FunctionInfo`` records -- and the statement ASTs they pin -- before L4."""
+    from codeanalyzer.dataflow.identity import IdentityMap
+
+    sig_to_callable: Dict[str, PyCallable] = {}
+    for module in app.symbol_table.values():
+        for pycallable, _chain in _walk_callables(module):
+            sig_to_callable[pycallable.signature] = pycallable
+    out: Dict[str, Set[Tuple[str, str, Optional[str]]]] = {}
+    for sig, info in infos.items():
+        pycallable = sig_to_callable.get(sig)
+        if pycallable is None:
+            continue
+        callable_id = sig_to_id.get(sig) or pycallable.id
+        im = IdentityMap.for_function(callable_id, info.pdg)
+        out[sig] = _ddg_local_set(im, info.pdg)
+    return out
+
+
 def emit_ddg_pointsto_delta(
     app: PyApplication,
-    syntactic_infos: Dict[str, FunctionInfo],
+    syntactic_infos,
     ir: ProgramGraphsIR,
     sig_to_id: Dict[str, str],
 ) -> None:
@@ -678,12 +723,14 @@ def emit_ddg_pointsto_delta(
         # untouched — they are L3's and this delta is strictly additive over them.
         pycallable.ddg = [e for e in pycallable.ddg if e.prov != ["points-to"]]
 
-        delta = _ddg_local_set(im, fg.pdg) - _ddg_local_set(im, syn.pdg)
+        # LOW-MEM PATCH: accept a precomputed syntactic set (see syntactic_ddg_sets).
+        syn_set = syn if isinstance(syn, (set, frozenset)) else _ddg_local_set(im, syn.pdg)
+        delta = _ddg_local_set(im, fg.pdg) - syn_set
         for src, dst, var in sorted(delta, key=lambda t: (t[0], t[1], t[2] or "")):
             if src not in pycallable.body or dst not in pycallable.body:
                 continue
             pycallable.ddg.append(
-                DdgEdge(src=src, dst=dst, var=var, prov=["points-to"])
+                DdgEdge(src=src, dst=dst, var=var, prov=_PROV_POINTS_TO)
             )
 
 

codeanalyzer/dataflow/cfg.py

@@ -102,7 +102,7 @@ EDGE_KINDS = (
 )
 
 
-@dataclass
+@dataclass(slots=True)  # LOW-MEM PATCH: slots
 class CFGNode:
     """A statement-level CFG node. ``id`` is assigned in source-span order
     after construction (ENTRY = 0, EXIT = last CFG id)."""
@@ -118,7 +118,7 @@ class CFGNode:
     ast_node: Optional[ast.AST] = field(default=None, repr=False, compare=False)
 
 
-@dataclass(frozen=True)
+@dataclass(slots=True, frozen=True)  # LOW-MEM PATCH: slots
 class CFGEdge:
     source: int
     target: int

codeanalyzer/dataflow/defuse.py

@@ -44,7 +44,7 @@ from codeanalyzer.dataflow.alias import TypeBasedAliasOracle
 from codeanalyzer.dataflow.cfg import ControlFlowGraph
 
 
-@dataclass(frozen=True)
+@dataclass(slots=True, frozen=True)  # LOW-MEM PATCH: slots
 class DDGEdge:
     source: int  # the def node
     target: int  # the use node

codeanalyzer/dataflow/pdg.py

@@ -42,7 +42,7 @@ from codeanalyzer.dataflow.defuse import ddg_edges
 from codeanalyzer.dataflow.dominance import control_dependence
 
 
-@dataclass(frozen=True)
+@dataclass(slots=True, frozen=True)  # LOW-MEM PATCH: slots
 class PDGEdge:
     source: int
     target: int

codeanalyzer/dataflow/sdg.py

@@ -59,7 +59,7 @@ CAPTURE_PREFIX = "<capture>:"
 GLOBAL_PREFIX = "<global>:"
 
 
-@dataclass
+@dataclass(slots=True)  # LOW-MEM PATCH: slots
 class ParamNode:
     id: int
     kind: str  # formal_in | formal_out | actual_in | actual_out
@@ -69,7 +69,7 @@ class ParamNode:
     end_line: int = -1
 
 
-@dataclass(frozen=True)
+@dataclass(slots=True, frozen=True)  # LOW-MEM PATCH: slots
 class SDGEdge:
     source_sig: str
     source_node: int
@@ -142,6 +142,26 @@ class _FunctionAssembler:
 
     # ---------------------------------------------------------------- formals
 
+    def formal_for(self, var: str) -> Optional[int]:
+        """The ``formal_in`` vertex that defines ``var`` in this callable.
+
+        A parameter, a capture and a read global are all defined at a
+        ``formal_in`` port, not at the synthetic CFG ENTRY node. Reaching-def
+        analysis reports ENTRY as the source for all three, so every place that
+        consumes a raw def source has to remap it here, or the SDG loses the
+        hop from the parameter to whatever uses it. Returns ``None`` when
+        ``var`` is not one of this callable's formals, so a caller can keep the
+        original source.
+        """
+        b = base_of(var)
+        if b in self.formal_in:
+            return self.formal_in[b]
+        if CAPTURE_PREFIX + b in self.formal_in:
+            return self.formal_in[CAPTURE_PREFIX + b]
+        if "::" in b and GLOBAL_PREFIX + b in self.formal_in:
+            return self.formal_in[GLOBAL_PREFIX + b]
+        return None
+
     def build_formals(self) -> None:
         scope, summary = self.scope, self.summary
         params = list(scope.params)
@@ -168,14 +188,8 @@ class _FunctionAssembler:
         for e in self.ddg:
             if e.source != entry:
                 continue
-            b = base_of(e.var)
-            if b in self.formal_in:
-                fid = self.formal_in[b]
-            elif CAPTURE_PREFIX + b in self.formal_in:
-                fid = self.formal_in[CAPTURE_PREFIX + b]
-            elif "::" in b and GLOBAL_PREFIX + b in self.formal_in:
-                fid = self.formal_in[GLOBAL_PREFIX + b]
-            else:
+            fid = self.formal_for(e.var)
+            if fid is None:
                 continue
             self.extra.append(PDGEdge(source=fid, target=e.target, type="DDG", var=e.var))
 
@@ -268,6 +282,8 @@ class _FunctionAssembler:
                         for src, var in self._defs_reaching_call_matching(
                             cs.node_id, path
                         ):
+                            if src == self.cfg.entry_id:
+                                src = self.formal_for(var) or src
                             self.extra.append(
                                 PDGEdge(source=src, target=aid, type="DDG", var=var)
                             )
@@ -296,6 +312,8 @@ class _FunctionAssembler:
                         for src, var in self._defs_reaching_call_matching(
                             cs.node_id, g
                         ):
+                            if src == self.cfg.entry_id:
+                                src = self.formal_for(var) or src
                             self.extra.append(
                                 PDGEdge(source=src, target=aid, type="DDG", var=var)
                             )

codeanalyzer/dataflow/summaries.py

@@ -102,15 +102,21 @@ def _is_global(path: str) -> bool:
 
 def augmented_facts(info: FunctionInfo, summaries: Dict[str, FunctionSummary]):
     """Per-node facts with callee global footprints injected at callsites."""
-    facts = {nid: f for nid, f in info.pdg.facts.items()}
-    out = {}
-    for nid, f in facts.items():
-        out[nid] = type(f)(defs=set(f.defs), uses=set(f.uses))
+    # LOW-MEM PATCH: copy-on-write. Only call-site nodes are ever augmented, and
+    # every downstream consumer (reaching-defs, flows, the SDG assembler) only
+    # reads facts, so the untouched nodes can share the PDG's own records
+    # instead of being deep-copied for every solve.
+    out = dict(info.pdg.facts)
+    copied = set()
     for cs in info.call_sites:
         for target in cs.targets:
             s = summaries.get(target)
             if s is None:
                 continue
+            if cs.node_id not in copied:
+                f = out[cs.node_id]
+                out[cs.node_id] = type(f)(defs=set(f.defs), uses=set(f.uses))
+                copied.add(cs.node_id)
             out[cs.node_id].uses |= s.global_reads
             out[cs.node_id].defs |= s.global_writes
     return out

codeanalyzer/entrypoints/matching.py

@@ -104,8 +104,12 @@ def _methods_of(dec, spec: Optional[Dict[str, Any]], qualified: Optional[str] =
         return []
     source = spec.get("from")
     if source == "match_suffix":
+        # Only a real verb: `heuristic.http-verb` also matches `.websocket`, and a
+        # rule may accept any suffix, but `http_methods` is what a consumer filters
+        # on to enumerate methods -- a value that is not one is worse there than an
+        # empty list (#213). The dispatch path below already filters the same way.
         verb = (qualified or dec.qualified_name or "").rsplit(".", 1)[-1]
-        return [verb.upper()]
+        return [verb.upper()] if verb.lower() in _HTTP_VERBS else []
     if source == "keyword":
         raw = (dec.keyword_arguments or {}).get(spec.get("name", ""))
         value = _literal(raw)

codeanalyzer/neo4j/cypher.py

@@ -156,3 +156,86 @@ def _edge_statements(edges: List[EdgeRow]) -> List[str]:
                 f"SET r += row.p;"
             )
     return blocks
+
+
+# ----------------------------------------------------------------------------------------------
+# LOW-MEM PATCH: streaming snapshot writer (see write_cypher_streaming).
+# ----------------------------------------------------------------------------------------------
+from codeanalyzer.neo4j.rows import EdgeRow, GraphRows, NodeRef, RowBuilder  # noqa: E402
+
+
+class _NodesOnlyBuilder(RowBuilder):
+    """Pass 1: nodes (merged props/labels, exactly as RowBuilder) + key set; no edges."""
+
+    def edge(self, type_, from_ref, to_ref, props=None, key=None):
+        return None
+
+    def edge_to_symbol(self, type_, from_ref, target_ref, props=None):
+        return None
+
+
+class _EdgeStreamBuilder(RowBuilder):
+    """Pass 2: nodes are already on disk; each edge batch is rendered with
+    ``_edge_statements`` (same grouping/BATCH) the moment it fills."""
+
+    def __init__(self, keys, fh):
+        super().__init__()
+        self._keys = keys
+        self._fh = fh
+        self._pending: Dict[str, List[EdgeRow]] = {}
+
+    def node(self, labels, key_prop, value, props):
+        return NodeRef(labels[0], key_prop, value)
+
+    def edge(self, type_, from_ref, to_ref, props=None, key=None):
+        e = EdgeRow(type_, from_ref, to_ref, dict(props or {}), key)
+        g = (
+            f"{e.type}|{e.from_ref.label}.{e.from_ref.key_prop}"
+            f"|{e.to_ref.label}.{e.to_ref.key_prop}|{e.key is not None}"
+        )
+        batch = self._pending.setdefault(g, [])
+        batch.append(e)
+        if len(batch) >= BATCH:
+            self._flush(g)
+
+    def edge_to_symbol(self, type_, from_ref, target_ref, props=None):
+        if (target_ref.label, target_ref.value) in self._keys:
+            self.edge(type_, from_ref, target_ref, props)
+
+    def _flush(self, g):
+        batch = self._pending.pop(g, None)
+        if batch:
+            for stmt in _edge_statements(batch):
+                self._fh.write(stmt)
+                self._fh.write("\n")
+
+    def finish(self) -> GraphRows:
+        for g in list(self._pending):
+            self._flush(g)
+        return GraphRows([], [])
+
+
+def write_cypher_streaming(fh, app, app_name: str, sig_to_id: dict, analyzer=None) -> None:
+    """Write the ``graph.cypher`` snapshot for ``app`` to ``fh`` without holding the
+    edge rows or the rendered text in memory (two projection passes)."""
+    from codeanalyzer.neo4j.project import project
+
+    nodes_b = _NodesOnlyBuilder()
+    project(app, app_name, sig_to_id, analyzer=analyzer, builder=nodes_b)
+    rows = nodes_b.finish()
+    keys = nodes_b._keys
+
+    fh.write("// ── constraints & indexes ──\n")
+    for stmt in CONSTRAINTS:
+        fh.write(f"{stmt};\n")
+    for stmt in INDEXES:
+        fh.write(f"{stmt};\n")
+    fh.write("\n// ── wipe this project's prior subgraph (externals/packages/decorators are shared) ──\n")
+    fh.write(_wipe(app_name) + "\n")
+    fh.write("\n// ── nodes ──\n")
+    for stmt in _node_statements(rows.nodes):
+        fh.write(stmt + "\n")
+    del rows, nodes_b
+
+    fh.write("\n// ── relationships ──\n")
+    project(app, app_name, sig_to_id, analyzer=analyzer, builder=_EdgeStreamBuilder(keys, fh))

codeanalyzer/neo4j/emit.py

@@ -29,7 +29,7 @@ from typing import Optional
 
 from codeanalyzer.neo4j.bolt import BoltConfig, bolt_writer
 from codeanalyzer.neo4j.schema import build_schema_document
-from codeanalyzer.neo4j.cypher import render_cypher
+from codeanalyzer.neo4j.cypher import render_cypher, write_cypher_streaming
 from codeanalyzer.neo4j.project import project
 from codeanalyzer.options import GRAPH_CYPHER, AnalysisOptions
 from codeanalyzer.schema import Analysis
@@ -58,9 +58,9 @@ def emit_neo4j(analysis: Analysis, options: AnalysisOptions) -> None:
     # canonical ``can://`` id and returns the ``signature -> id`` map the projection
     # keys nodes on, so the JSON and Neo4j projections agree.
     sig_to_id = assign_ids(analysis.application, app_name)
-    rows = project(analysis.application, app_name, sig_to_id, analyzer=analysis.analyzer)
 
     if options.neo4j_uri:
+        rows = project(analysis.application, app_name, sig_to_id, analyzer=analysis.analyzer)
         cfg = BoltConfig(
             uri=options.neo4j_uri,
             user=options.neo4j_user,
@@ -76,5 +76,7 @@ def emit_neo4j(analysis: Analysis, options: AnalysisOptions) -> None:
     out_dir = options.output if options.output is not None else Path.cwd()
     out_dir.mkdir(parents=True, exist_ok=True)
     target = out_dir / GRAPH_CYPHER
-    target.write_text(render_cypher(rows, app_name))
+    with target.open("w") as fh:  # LOW-MEM PATCH: streamed, see cypher.write_cypher_streaming
+        write_cypher_streaming(fh, analysis.application, app_name, sig_to_id,
+                               analyzer=analysis.analyzer)
     logger.info(f"Neo4j graph written to {target}")

codeanalyzer/neo4j/project.py

@@ -56,11 +56,11 @@ from codeanalyzer.schema.py_schema import PyDecorator, byte_offsets
 
 
 def project(app: PyApplication, app_name: str, sig_to_id: dict,
-            analyzer: Optional[Any] = None) -> GraphRows:
+            analyzer: Optional[Any] = None, builder: Optional[RowBuilder] = None) -> GraphRows:
     """``analyzer`` is the envelope-level ``PyAnalyzerInfo`` (the keystone home
     for analyzer identity); the caller that holds the ``Analysis`` envelope
     passes it through so the :PyApplication node carries it as props."""
-    b = RowBuilder()
+    b = builder if builder is not None else RowBuilder()  # LOW-MEM PATCH
 
     # Keyed on the ``can://<app>`` id, not on ``--app-name``: two applications
     # analyzed under the same free-text name used to MERGE onto one root, with
@@ -928,6 +928,9 @@ def _stringify_if(value: Any) -> Optional[str]:
 
 
 def _jsonable(o: Any) -> Any:
+    import dataclasses as _dc  # LOW-MEM PATCH: slotted-dataclass schema leaves
+    if _dc.is_dataclass(o) and not isinstance(o, type):
+        return _dc.asdict(o)
     if hasattr(o, "model_dump"):
         return o.model_dump()
     if hasattr(o, "dict"):

codeanalyzer/schema/__init__.py

@@ -1,6 +1,3 @@
-from importlib.metadata import version, PackageNotFoundError
-from packaging.version import parse as parse_version
-
 from .py_schema import (
     Analysis,
     BodyNode,
@@ -43,25 +40,10 @@ __all__ = [
     "ParamEdge",
 ]
 
-try:
-    pydantic_version = version("pydantic")
-except PackageNotFoundError:
-    pydantic_version = "0.0.0"  # fallback or raise if appropriate
-
-PYDANTIC_V2 = parse_version(pydantic_version) >= parse_version("2.0.0")
+# Pydantic v2 is the only supported major since Python 3.11 became the floor;
+# kept as a constant for importers that still branch on it.
+PYDANTIC_V2 = True
 
-if not PYDANTIC_V2:
-    # Safe to pass localns
-    PyCallable.update_forward_refs(PyClass=PyClass)
-    PyClass.update_forward_refs(PyCallable=PyCallable)
-    PyModule.update_forward_refs(PyCallable=PyCallable, PyClass=PyClass)
-    PyApplication.update_forward_refs(
-        PyCallable=PyCallable,
-        PyClass=PyClass,
-        PyModule=PyModule
-    )
-    Analysis.update_forward_refs(PyApplication=PyApplication)
-    
 # Fields the analyzer keeps in memory (and in the cache) but never emits.
 # `call_sites` is the internal record `body{}` call nodes are derived from (#120);
 # emitting both shipped the same fact twice under two identity schemes.
@@ -87,50 +69,27 @@ def strip_internal_only(data):
     return data
 
 
-# Compatibility helpers for Pydantic v1/v2
+# Serialization helpers, kept as the one call site for every dump/copy/load.
 def model_dump_json(model, **kwargs):
-    """Compatibility helper for JSON serialization."""
-    if PYDANTIC_V2:
-        return model.model_dump_json(**kwargs)
-    else:
-        # Map Pydantic v2 parameters to v1 equivalents
-        v1_kwargs = {}
-        if 'indent' in kwargs:
-            v1_kwargs['indent'] = kwargs['indent']
-        if 'exclude_none' in kwargs:
-            v1_kwargs['exclude_none'] = kwargs['exclude_none']
-        if 'separators' in kwargs:
-            # In v1, separators is passed to dumps_kwargs
-            v1_kwargs['separators'] = kwargs['separators']
-        return model.json(**v1_kwargs)
+    """Serialize a model to a JSON string."""
+    return model.model_dump_json(**kwargs)
 
 def model_dump(model, **kwargs):
-    """Compatibility helper for dict serialization (v2 model_dump / v1 dict).
-
-    ``mode="json"`` (v2) maps to a json round-trip on v1 so both versions
-    yield JSON-safe primitives.
-    """
-    if PYDANTIC_V2:
-        return model.model_dump(**kwargs)
-    import json as _json
-    mode = kwargs.pop("mode", None)
-    v1_kwargs = {k: v for k, v in kwargs.items() if k in ("exclude_none", "exclude")}
-    if mode == "json":
-        return _json.loads(model.json(**v1_kwargs))
-    return model.dict(**v1_kwargs)
+    """Serialize a model to a dict (``mode="json"`` yields JSON-safe primitives)."""
+    return model.model_dump(**kwargs)
 
 
 def model_copy(model):
-    """Compatibility helper for copying a model (v2 model_copy / v1 copy)."""
-    return model.model_copy() if PYDANTIC_V2 else model.copy()
+    """Shallow-copy a model or a dataclass leaf."""
+    import copy as _copy, dataclasses as _dc
+    if _dc.is_dataclass(model):  # LOW-MEM PATCH: slotted dataclass leaf (shallow copy, like model_copy)
+        return _copy.copy(model)
+    return model.model_copy()
 
 
 def model_validate_json(model_class, json_data):
-    """Compatibility helper for JSON deserialization."""
-    if PYDANTIC_V2:
-        return model_class.model_validate_json(json_data)
-    else:
-        return model_class.parse_raw(json_data)
+    """Deserialize a model from a JSON string."""
+    return model_class.model_validate_json(json_data)
 
 __all__.extend([
     "PYDANTIC_V2",

codeanalyzer/schema/py_schema.py

@@ -21,6 +21,8 @@ for static analysis purposes.
 """
 from __future__ import annotations
 from pathlib import Path
+import dataclasses as _dataclasses
+from dataclasses import dataclass, field as _dc_field
 from typing import Any, Dict, List, Optional, Tuple
 from pydantic import BaseModel
 from typing_extensions import Literal
@@ -50,22 +52,27 @@ def builder(cls):
     # defaults straight off the model instead. Required fields are intentionally
     # omitted (seeded ``None``) — the builder chain must set them.
     defaults = {}
-    model_fields = getattr(cls, "model_fields", None)  # Pydantic v2
-    if model_fields:
-        for name, field in model_fields.items():
+    factories = {}  # LOW-MEM PATCH: dataclass default_factory, called per builder
+    if _dataclasses.is_dataclass(cls):  # LOW-MEM PATCH: slotted dataclass leaf
+        for f in _dataclasses.fields(cls):
+            if f.default is not _dataclasses.MISSING:
+                defaults[f.name] = f.default
+            elif f.default_factory is not _dataclasses.MISSING:
+                factories[f.name] = f.default_factory
+    else:
+        for name, field in cls.model_fields.items():
             if not field.is_required():
                 defaults[name] = field.get_default(call_default_factory=True)
-    else:  # Pydantic v1
-        for name, field in getattr(cls, "__fields__", {}).items():
-            if not field.required:
-                defaults[name] = field.get_default()
     # Create a namespace for the builder class.
     namespace = {}
 
     # Create an __init__ method for the builder class that initializes all fields to their default values.
     def __init__(self):
         for field in annotations:
-            default = defaults.get(field, None)
+            if field in factories:  # LOW-MEM PATCH: fresh mutable default per instance
+                default = factories[field]()
+            else:
+                default = defaults.get(field, None)
             setattr(self, f"_{field}", default)
 
     namespace["__init__"] = __init__
@@ -114,8 +121,13 @@ def byte_offsets(source: str, start_line: int, start_col: int,
     return offset(start_line, start_col), offset(end_line, end_col)
 
 
-@builder
-class Span(BaseModel):
+# LOW-MEM PATCH: the per-statement / per-edge records below are the bulk of a
+# large project's tree (tens of millions of instances). As pydantic models each
+# instance costs ~650 B (``__dict__`` + ``__pydantic_fields_set__`` + ...); as
+# slotted stdlib dataclasses ~230 B, and pydantic serializes/validates them
+# identically when they appear as fields of the enclosing models.
+@dataclass(slots=True)
+class Span:
     """Where a node lives in source. `start`/`end` are [line, col] (1-based line,
     0-based col, ast semantics); `bytes` are utf-8 offsets into module.source."""
     start: Tuple[int, int]
@@ -123,8 +135,8 @@ class Span(BaseModel):
     bytes: Tuple[int, int]
 
 
-@builder
-class BodyNode(BaseModel):
+@dataclass(slots=True)
+class BodyNode:
     """A node in a callable's `body`: an AST region (statement/call/branch/…) or
     a synthetic analysis vertex (entry/exit/formal_in/out/actual_in/out)."""
     kind: str
@@ -146,31 +158,31 @@ class BodyNode(BaseModel):
     receiver_type: Optional[str] = None
     return_type: Optional[str] = None
     is_constructor_call: Optional[bool] = None
-    arguments: List["PyCallArgument"] = []
+    arguments: List["PyCallArgument"] = _dc_field(default_factory=list)
 
 
-@builder
-class CfgEdge(BaseModel):
+@dataclass(slots=True)
+class CfgEdge:
     src: str; dst: str; kind: str = "fallthrough"
 
 
-@builder
-class CdgEdge(BaseModel):
+@dataclass(slots=True)
+class CdgEdge:
     src: str; dst: str
 
 
-@builder
-class DdgEdge(BaseModel):
-    src: str; dst: str; var: Optional[str] = None; prov: List[str] = []
+@dataclass(slots=True)
+class DdgEdge:
+    src: str; dst: str; var: Optional[str] = None; prov: List[str] = _dc_field(default_factory=list)
 
 
-@builder
-class SummaryEdge(BaseModel):
+@dataclass(slots=True)
+class SummaryEdge:
     src: str; dst: str
 
 
-@builder
-class ParamEdge(BaseModel):
+@dataclass(slots=True)
+class ParamEdge:
     """A `param_in` (actual_in → formal_in) or `param_out` (formal_out → actual_out)
     edge at application scope. `var` is the callee-side formal's variable — the
     parameter name, or `<return>` for the return port — always set (#195), the
@@ -180,7 +192,8 @@ class ParamEdge(BaseModel):
 
 
 @builder
-class PyImport(BaseModel):
+@dataclass(slots=True)  # LOW-MEM PATCH: leaf record
+class PyImport:
     """Represents a Python import statement."""
 
     module: str
@@ -194,7 +207,8 @@ class PyImport(BaseModel):
 
 
 @builder
-class PyComment(BaseModel):
+@dataclass(slots=True)  # LOW-MEM PATCH: leaf record
+class PyComment:
     """Represents a Python comment."""
 
     content: str
@@ -206,7 +220,8 @@ class PyComment(BaseModel):
 
 
 @builder
-class PySymbol(BaseModel):
+@dataclass(slots=True)  # LOW-MEM PATCH: leaf record
+class PySymbol:
     """Represents a symbol used or declared in Python code."""
 
     name: str
@@ -220,7 +235,8 @@ class PySymbol(BaseModel):
 
 
 @builder
-class PyVariableDeclaration(BaseModel):
+@dataclass(slots=True)  # LOW-MEM PATCH: leaf record
+class PyVariableDeclaration:
     """Represents a Python variable declaration."""
 
     name: str
@@ -238,7 +254,8 @@ class PyVariableDeclaration(BaseModel):
 
 
 @builder
-class PyDecorator(BaseModel):
+@dataclass(slots=True)  # LOW-MEM PATCH: leaf record
+class PyDecorator:
     """One decorator application, structured rather than a source string (#128).
 
     ``name`` is the spelling as written (``lru_cache``, ``builtins.staticmethod``);
@@ -249,8 +266,8 @@ class PyDecorator(BaseModel):
 
     name: str
     qualified_name: Optional[str] = None
-    positional_arguments: List[str] = []
-    keyword_arguments: Dict[str, str] = {}
+    positional_arguments: List[str] = _dc_field(default_factory=list)
+    keyword_arguments: Dict[str, str] = _dc_field(default_factory=dict)
     expression: str = ""
     span: Optional[Span] = None
 
@@ -291,7 +308,8 @@ class PyEntrypointReport(BaseModel):
 
 
 @builder
-class PyCallableParameter(BaseModel):
+@dataclass(slots=True)  # LOW-MEM PATCH: leaf record
+class PyCallableParameter:
     """Represents a parameter of a Python callable (function/method)."""
 
     name: str
@@ -300,7 +318,7 @@ class PyCallableParameter(BaseModel):
     id: str = ""
     type: Optional[str] = None
     default_value: Optional[str] = None
-    decorators: List[PyDecorator] = []
+    decorators: List[PyDecorator] = _dc_field(default_factory=list)
     start_line: int = -1
     end_line: int = -1
     start_column: int = -1
@@ -308,7 +326,8 @@ class PyCallableParameter(BaseModel):
 
 
 @builder
-class PyCallArgument(BaseModel):
+@dataclass(slots=True)  # LOW-MEM PATCH: leaf record
+class PyCallArgument:
     """One call-site argument: AST category + inferred type, kept separate.
 
     The legacy ``PyCallsite.argument_types`` mixed these two vocabularies
@@ -330,22 +349,16 @@ class PyCallArgument(BaseModel):
     name: Optional[str] = None
 
 
-# BodyNode.arguments forward-references PyCallArgument (defined later);
-# pydantic v1 resolves string annotations only when told to, while v2
-# rebuilds automatically (and its update_forward_refs shim rejects localns).
-if not hasattr(BodyNode, "model_rebuild"):  # pydantic v1
-    BodyNode.update_forward_refs(PyCallArgument=PyCallArgument)
-
-
 @builder
-class PyCallsite(BaseModel):
+@dataclass(slots=True)  # LOW-MEM PATCH: leaf record
+class PyCallsite:
     """Represents a Python call site (function or method invocation) with contextual metadata."""
 
     method_name: str
     receiver_expr: Optional[str] = None
     receiver_type: Optional[str] = None
-    argument_types: List[str] = []
-    arguments: List[PyCallArgument] = []
+    argument_types: List[str] = _dc_field(default_factory=list)
+    arguments: List[PyCallArgument] = _dc_field(default_factory=list)
     return_type: Optional[str] = None
     callee_signature: Optional[str] = None
     is_constructor_call: bool = False
@@ -464,7 +477,8 @@ class PyModule(BaseModel):
 
 
 @builder
-class PyCallEdge(BaseModel):
+@dataclass(slots=True)  # LOW-MEM PATCH: ~1M instances on a large project
+class PyCallEdge:
     """Identity-only call-graph edge with weight (keystone shape: the list name
     IS the edge type, so there is no ``type`` field).
 
@@ -477,7 +491,7 @@ class PyCallEdge(BaseModel):
     src: str  # caller callable id
     dst: str  # callee callable (or external) id
     weight: int = 1
-    prov: List[Literal["jedi", "defuse"]] = []
+    prov: List[Literal["jedi", "defuse"]] = _dc_field(default_factory=list)
 
 
 @builder

{codeanalyzer_python-1.5.3.dist-info → codeanalyzer_python-1.6.0.dist-info}/METADATA

@@ -1,31 +1,23 @@
 Metadata-Version: 2.5
 Name: codeanalyzer-python
-Version: 1.5.3
+Version: 1.6.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
 License-File: NOTICE
-Requires-Python: >=3.9
+Requires-Python: >=3.11
 Requires-Dist: astor<0.9.0,>=0.8.1
-Requires-Dist: jedi<0.20.0,>=0.18.0; python_version < '3.11'
-Requires-Dist: jedi<=0.19.2; python_version >= '3.11'
-Requires-Dist: networkx<3.2.0,>=2.6.0; python_version < '3.11'
-Requires-Dist: networkx<4.0.0,>=3.0.0; python_version >= '3.11'
+Requires-Dist: jedi<=0.19.2
+Requires-Dist: networkx<4.0.0,>=3.0.0
 Requires-Dist: packaging>=25.0
 Requires-Dist: parso>=0.8.5
-Requires-Dist: pydantic<2.0.0,>=1.8.0; python_version < '3.11'
-Requires-Dist: pydantic<3.0.0,>=2.0.0; python_version >= '3.11'
+Requires-Dist: pydantic<3.0.0,>=2.0.0
 Requires-Dist: pyyaml<7.0,>=6.0
-Requires-Dist: ray<3.0.0,>=2.10.0; python_version >= '3.11'
-Requires-Dist: ray==2.0.0; python_version < '3.11'
-Requires-Dist: requests<3.0.0,>=2.20.0; python_version >= '3.11'
-Requires-Dist: rich<14.0.0,>=12.6.0; python_version < '3.11'
-Requires-Dist: rich<15.0.0,>=14.0.0; python_version >= '3.11'
-Requires-Dist: tomli>=2.0; python_version < '3.11'
-Requires-Dist: typer<1.0.0,>=0.9.0; python_version < '3.11'
-Requires-Dist: typer<2.0.0,>=0.9.0; python_version >= '3.11'
-Requires-Dist: typing-extensions<5.0.0,>=4.0.0; python_version < '3.11'
-Requires-Dist: typing-extensions<6.0.0,>=4.5.0; python_version >= '3.11'
+Requires-Dist: ray<3.0.0,>=2.10.0
+Requires-Dist: requests<3.0.0,>=2.20.0
+Requires-Dist: rich<15.0.0,>=14.0.0
+Requires-Dist: typer<2.0.0,>=0.9.0
+Requires-Dist: typing-extensions<6.0.0,>=4.5.0
 Requires-Dist: uv>=0.5.0
 Provides-Extra: neo4j
 Requires-Dist: neo4j<6.0.0,>=5.0.0; extra == 'neo4j'
@@ -112,7 +104,7 @@ needs.
 
 ### Prerequisites
 
-- **Python 3.10 or newer.**
+- **Python 3.11 or newer.**
 - A C toolchain and the `venv` / development headers — the analyzer builds an isolated virtual
   environment per project (via Python's `venv`) so Jedi can resolve types and imports:
 

{codeanalyzer_python-1.5.3.dist-info → codeanalyzer_python-1.6.0.dist-info}/RECORD

@@ -1,29 +1,29 @@
 codeanalyzer/__init__.py,sha256=BZ3Kuwl-F_F-8H8cepLnVJ4Ku4NNUjjqg0Y6ujPQSsI,108
-codeanalyzer/__main__.py,sha256=noiZpfaiyFlnmdzHoWOAImXpxDkiQzTxSO4gmyZVyGI,15981
-codeanalyzer/core.py,sha256=UoK-7xgzJx-f3A_fmmeEZkBshiOWNDwc_RJTPhCTU0Y,47655
+codeanalyzer/__main__.py,sha256=eSp7cOmEKZ-BJn4C4JrPdNil3lVrE06yajPOr0iTTso,16027
+codeanalyzer/core.py,sha256=bclHJjcJPYJbXbq1-tqaBXDeTIbdA1G4dkUKzjX-nXk,53184
 codeanalyzer/provenance.py,sha256=DT-DqwdVwO7g-GyK3sC0_4vDNCUjZYEY1fyYCt-7VRM,2306
 codeanalyzer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codeanalyzer/artifacts/__init__.py,sha256=317sEeZLS1AYsfYDYIk7tLR3AdDFwWw_cmkeZDabkJo,906
-codeanalyzer/artifacts/config_keys.py,sha256=ovwptAErLYutlCzUwvyim2kH6-6vUKxuRcBV2KJS71Y,26843
+codeanalyzer/artifacts/config_keys.py,sha256=ki3ImlNMc9QfN1heEOzjbbeMaZf6gO7LQv3tje_xF_w,26710
 codeanalyzer/artifacts/config_use.py,sha256=1-jGacW249dwF7b6DOrTFuJ7sA5Ho9khgrgZqND0nro,27173
 codeanalyzer/artifacts/config_use_rules.yml,sha256=fNgI6IceOsj78LYmgoDH-vQ4-Mfb2ZFGKIQhLuoL4ik,1483
 codeanalyzer/artifacts/dependencies.py,sha256=h_-XV5KhrT-1Ytguw0c4fyI9zSFzn9Aj7kR66omvL3M,10853
 codeanalyzer/artifacts/discovery.py,sha256=urN4ZvtnXs0w9Kv2-yeOQza1TV1mjLL007zHfbdjNSg,8416
-codeanalyzer/artifacts/parsers.py,sha256=xOjC53tT0Mv0k7ONGwzl5XUvpBLnZlEcGmyrX5DS45k,9035
+codeanalyzer/artifacts/parsers.py,sha256=ZxO0d7whPPh4o-cb0PIsUYK3iNZfxaePqcBQn66OvDg,8902
 codeanalyzer/dataflow/__init__.py,sha256=HCNOH24rAGLUMG94N9aC-2SsAWSntk3uys7e39ipU5o,1725
-codeanalyzer/dataflow/access_paths.py,sha256=wC8Q9qD-RZzkoFWMVvu_6uNNmYP8z48OGp9h9v3F1d4,23623
+codeanalyzer/dataflow/access_paths.py,sha256=rbH_5AhTvR3C6s4OCiIuZTY2qSjDcxgovBXeHO2HURM,23659
 codeanalyzer/dataflow/alias.py,sha256=ZYKY0DiR3GHv6YJr7C001Lode9rZsk6-gxdomUyIvwg,3928
-codeanalyzer/dataflow/builder.py,sha256=Ku16XuEJj46lnfuigMMyR6yheRW52f5U-ih9msxqSyo,33402
-codeanalyzer/dataflow/cfg.py,sha256=u5YXJjAaDshdgv-9kWWITbBJFP-MwXKq6hbNh0fhDm8,25307
-codeanalyzer/dataflow/defuse.py,sha256=LrX1ToOZzR79NlAGg5T647UAFkpiEqEnT7t0K5RXOiI,4377
+codeanalyzer/dataflow/builder.py,sha256=Q2T1r7rpLnhpZSaGB2uOd0ugPDkd9vCuUrIaUMiHv6A,35587
+codeanalyzer/dataflow/cfg.py,sha256=ilXFzDSoBEAYszmf1LlGAdlEae41WrkO1SmbCTNTv9U,25379
+codeanalyzer/dataflow/defuse.py,sha256=-rxJl6dlMXPfysm8XcjDXzpNFNlCYNJ0XBDAhKe7PSk,4413
 codeanalyzer/dataflow/dominance.py,sha256=X7Ki1QRdVqaseYsJtiUL7m9MbcC2WHEv9b8bczSLFUA,5086
 codeanalyzer/dataflow/identity.py,sha256=6aAz3iPSOpoS7l_moC7XGr2RS_GqJp_FlsWGglMJDjM,3812
-codeanalyzer/dataflow/pdg.py,sha256=1Bm7AnoRqXBryZulII2idPw0feV8eZQ1VqqprQ8PW-g,3731
+codeanalyzer/dataflow/pdg.py,sha256=_BbyrqYF-FTs98MqQY5f3qeiDqaHqLS_Ox6tZCcoiRk,3767
 codeanalyzer/dataflow/scalpel_oracle.py,sha256=FxRadKrTWar0VKHyQJM40n3cq25sld3Sj4lMdOm5NFk,11494
 codeanalyzer/dataflow/scc.py,sha256=Doa_0-5f3agCu_5UmeEDlCUErg34TtniKIv8Uqd7Jiw,3493
-codeanalyzer/dataflow/sdg.py,sha256=taDXkIg0BZUtDEJUjRJB_dxrFl6tKNOUdFyj0zCiso0,18533
+codeanalyzer/dataflow/sdg.py,sha256=SaR-fi86gKhs2lz9xYtXTpYdxKmjMYRhb8QGp25VtGw,19517
 codeanalyzer/dataflow/slicing.py,sha256=lWZ7jHhlR8m7rECWJQXvwfs5GNZeJY55Cud3Ji5UbNU,3654
-codeanalyzer/dataflow/summaries.py,sha256=TLtc5h4bLBC4lViuMhMlEp5rp_nBpDPOl4_wfBuRUY4,9210
+codeanalyzer/dataflow/summaries.py,sha256=VZRly_6CEHUrvBxV8_cBM5b-oG4v65jDrH_vZD2Knfk,9573
 codeanalyzer/dataflow/syntactic.py,sha256=AbHyXjKX_1xkGgKH48BpXYCWBauActGUwSMF_OD-uys,1124
 codeanalyzer/dataflow/scalpel/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 codeanalyzer/dataflow/scalpel/README.md,sha256=YN-LxqYYDekIdhx39AG28sg9UySMmqvLQJivTvR2Fz8,1543
@@ -38,7 +38,7 @@ codeanalyzer/dataflow/scalpel/core/func_call_visitor.py,sha256=ps0snjTchBXilhor3
 codeanalyzer/dataflow/scalpel/core/vars_visitor.py,sha256=gE5fNyJS6jslD6vsMRbFLoy3n1xTwH-b54mBcNYO72M,5660
 codeanalyzer/entrypoints/__init__.py,sha256=VaMd4mSEPLuPlRxxAve_nTJ9ZH62stXZGTPNwU_BQ50,99
 codeanalyzer/entrypoints/detect.py,sha256=fsWRQz1njvB9d3LIJEHxsNFE1GrB7q52KCvozw_UIUQ,4594
-codeanalyzer/entrypoints/matching.py,sha256=rQeY_w2dyG36DBUjle7GLXxqDKsoMhJYPjN4s11OGtM,7948
+codeanalyzer/entrypoints/matching.py,sha256=fppta04o1_HWBEHe6boV_7T964cdLuZlOoQHAW4yt0Q,8321
 codeanalyzer/entrypoints/pipeline.py,sha256=vVSdttMfSAWour2fsC3LomMtwFLzRqmJHixJS82VY1I,7828
 codeanalyzer/entrypoints/rules.py,sha256=yG772JHmNc2L10jIpxfg1xTh-QouJa6lNU9ubo3EZYg,6003
 codeanalyzer/entrypoints/rules.yml,sha256=sguICRfDDNGjJPfZz-JSwkI_hzbTJaau1liHV_y4rTA,4637
@@ -46,20 +46,20 @@ codeanalyzer/jedi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 codeanalyzer/jedi/jedi.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codeanalyzer/neo4j/__init__.py,sha256=8Ei6uThTOqmul6GhnKoGOjLXJZbyDwF5Jo-8I8NxnAk,1574
 codeanalyzer/neo4j/bolt.py,sha256=8l70iGDjY3Kdm-W1sb3b3O1uqLjDrVPYTpXhnkXdZOY,13694
-codeanalyzer/neo4j/cypher.py,sha256=-wledvXVrcLJRtSC5MCn1N3tqgC06rNfPBn0w6POqHo,6239
-codeanalyzer/neo4j/emit.py,sha256=7QYosqiadH2GIsjaUSmSlJ5g8yLjAAcMplsmFaJLnC4,3599
-codeanalyzer/neo4j/project.py,sha256=o6jdjwvHRxpNPNn-DXpOzebFq-fXgxoXTrKZ4_2ZVbQ,42383
+codeanalyzer/neo4j/cypher.py,sha256=cQ3lY7ffbNYdIhFqbxn8l3boh7tBlGqyM3jRXvs63JU,9406
+codeanalyzer/neo4j/emit.py,sha256=R8rJjTPOSA5AXO0eTQqY5QTdoIxph_EPiT5478fL8WM,3806
+codeanalyzer/neo4j/project.py,sha256=CC-Pu6-QPW5jLimCAjCRXPDVn9pFFwWqO3K3NxGaEiA,42639
 codeanalyzer/neo4j/rows.py,sha256=n_J3NVIusLPsHMjPCWaYvlL5sFm6V-kl_Z6B_BTH8Fk,10140
 codeanalyzer/neo4j/schema.py,sha256=0qZ1qJgmutlMHyIjdfD5N9QtA-gwl8Qcgh4NGguQEMs,18089
 codeanalyzer/options/__init__.py,sha256=HvKzVXBI91lBM941JSFN7npG4S2fHlVEKo9VC2lRso8,156
 codeanalyzer/options/options.py,sha256=DAo1i08D0K16jCivTrdOcBgKRPO50SngFZTPAL_kpmY,1862
-codeanalyzer/schema/__init__.py,sha256=hIyz02abUJNPW8yUgguaeKflZjTmOZWbDiKICNBD7yk,4141
+codeanalyzer/schema/__init__.py,sha256=4eyp9AXJBLE9mNLsUbNGdOD_UvGQ-8GTj-qm7CVJg6g,2731
 codeanalyzer/schema/assign_ids.py,sha256=pQHluLaO5a6hFREp3vjVRsUeAfTYSJ95RXS9TZvnoys,1590
 codeanalyzer/schema/call_graph_ids.py,sha256=mWAhJDBsW8i-siJiINOHCXEm4qM6F_5se9-HuHWIFqU,568
 codeanalyzer/schema/ids.py,sha256=eShvV3R6oQt1lCQ2DFAhWekSWom63wQJDfeWXJ7KovQ,5986
 codeanalyzer/schema/l1_body.py,sha256=-rBXZH1nhaCyQ2DVN-iIswuuSQ7Jsa8voSAaljv_c80,1737
 codeanalyzer/schema/l2_callees.py,sha256=UGubBSLA_-GCK9Kak2rqkmoFlGifiImVnPDrypjHfrA,2441
-codeanalyzer/schema/py_schema.py,sha256=4xJto32nWqHx0dkge4qHsV2JZSjbyv4ojnqpyBm78sQ,24588
+codeanalyzer/schema/py_schema.py,sha256=tVNLHR1lcimb-osSHSjXvkoJVHWtilDeZBBgVWMWsC4,25687
 codeanalyzer/semantic_analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codeanalyzer/semantic_analysis/call_graph.py,sha256=6YEB_wTn5-oQYLrbIhJYE0BsHl4fpWPoy5Hwd9mTnGc,11918
 codeanalyzer/semantic_analysis/defuse_linker.py,sha256=3n1ew94eyBsSI98cFqP0uMHFUv7ob7QR9DL2hTKMHsQ,65099
@@ -70,9 +70,9 @@ codeanalyzer/syntactic_analysis/symbol_table_builder.py,sha256=tKed-VCSd_albMeZf
 codeanalyzer/utils/__init__.py,sha256=hC6VWdR5rerSqBxzu9KQHTASWqwrrYJv-CMDwrTlzkc,137
 codeanalyzer/utils/logging.py,sha256=Fw0tattPAOMs3o0JMjjXhRVLIF64f-SCcygUXF9jqeg,904
 codeanalyzer/utils/progress_bar.py,sha256=C9JtzVdd10lIxTv-KA6PebqjKWueC_vMGwVzAtHuHIw,2818
-codeanalyzer_python-1.5.3.dist-info/METADATA,sha256=mYN0yUedKfOOzWquD1DxyaoE3c9yUpK9Prs9AXqj6d0,44845
-codeanalyzer_python-1.5.3.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-codeanalyzer_python-1.5.3.dist-info/entry_points.txt,sha256=v4Vux0Nnx7sOntVk_CH7W9RX6SkIkvR1FQYq73oVlCQ,105
-codeanalyzer_python-1.5.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-codeanalyzer_python-1.5.3.dist-info/licenses/NOTICE,sha256=MdVkNYqHJ20on2FmWvgD4WpMsX5mir33xdyPvTXd0A0,1223
-codeanalyzer_python-1.5.3.dist-info/RECORD,,
+codeanalyzer_python-1.6.0.dist-info/METADATA,sha256=r7izrINncIgH_0mITPQWdmyaz4Gp3YHp5OJah_2KUsk,44156
+codeanalyzer_python-1.6.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+codeanalyzer_python-1.6.0.dist-info/entry_points.txt,sha256=v4Vux0Nnx7sOntVk_CH7W9RX6SkIkvR1FQYq73oVlCQ,105
+codeanalyzer_python-1.6.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+codeanalyzer_python-1.6.0.dist-info/licenses/NOTICE,sha256=MdVkNYqHJ20on2FmWvgD4WpMsX5mir33xdyPvTXd0A0,1223
+codeanalyzer_python-1.6.0.dist-info/RECORD,,

{codeanalyzer_python-1.5.3.dist-info → codeanalyzer_python-1.6.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.32.0
+Generator: hatchling 1.32.4
 Root-Is-Purelib: true
 Tag: py3-none-any