codeanalyzer-python 1.5.1__py3-none-any.whl → 1.5.2__py3-none-any.whl

codeanalyzer/neo4j/project.py

@@ -50,7 +50,7 @@ from codeanalyzer.schema import (
 )
 from codeanalyzer.schema import model_dump
 from codeanalyzer.schema.ids import application_id, external_id, global_ordinal, purl_pypi
-from codeanalyzer.schema.py_schema import PyDecorator
+from codeanalyzer.schema.py_schema import PyDecorator, byte_offsets
 
 
 def project(app: PyApplication, app_name: str, sig_to_id: dict,
@@ -182,6 +182,15 @@ def _project_program_graphs(
             if not c.id:
                 continue  # unstamped callable — assign_ids must run first
             owner = _sym(c.id)  # the :PyCallable node, keyed by its can:// id
+            # ``callee_signature`` lives on ``PyCallable.call_sites``, not on the body
+            # node, so the graph joins the two on the call site's position (#203).
+            # ``argument_types`` is deliberately not joined: it is the legacy field #86
+            # split into ``PyCallArgument``, already carried as ``arguments_json``.
+            sig_by_pos = {
+                (cs.start_line, cs.start_column): cs.callee_signature
+                for cs in (c.call_sites or [])
+                if cs.callee_signature
+            }
             for local_key, node in (c.body or {}).items():
                 span = node.span
                 # L4 param vertices carry the variable they model (``of``) and
@@ -194,8 +203,11 @@ def _project_program_graphs(
                     prune(
                         {
                             "kind": node.kind,
-                            "start_line": span.start[0] if span else None,
-                            "end_line": span.end[0] if span else None,
+                            **_span_props(span),
+                            "callee_signature": (
+                                sig_by_pos.get((span.start[0], span.start[1]))
+                                if span else None
+                            ),
                             "var": node.of,
                             "call_node": node.parent,
                             # Call-site detail (#120). The JSON emits one node per
@@ -346,8 +358,7 @@ def _project_artifacts(b: RowBuilder, app: PyApplication, app_name: str, app_ref
                         "namespace": ck.namespace,
                         "value": ck.value,
                         "references": list(ck.references or []),
-                        "start_line": ck.span.start[0] if ck.span else None,
-                        "end_line": ck.span.end[0] if ck.span else None,
+                        **_span_props(ck.span),
                     }
                 ),
             )
@@ -569,7 +580,7 @@ def _project_module_body(
         _project_class(b, file_key, mod_ref, "PY_DECLARES", cl, externals, sig_to_id,
                        mod.source, base_ref)
     for v in mod.variables or []:
-        _project_variable(b, file_key, mod_ref, v)
+        _project_variable(b, file_key, mod_ref, v, mod.source or "")
     _project_imports(b, mod_ref, mod, module_id_by_key)
 
 
@@ -597,9 +608,15 @@ def _project_imports(b: RowBuilder, mod_ref: NodeRef, mod: PyModule,
             continue
         key = im.resolved_module or im.module
         a = agg.setdefault(
-            key, {"spellings": set(), "names": set(), "aliases": set(), "resolved": im.resolved_module}
+            key,
+            {"spellings": set(), "names": set(), "aliases": set(), "positions": {},
+             "resolved": im.resolved_module},
         )
         a["spellings"].add(im.module)
+        # Keyed by spelling, never by index: ``spellings`` is emitted sorted, so a
+        # parallel position array has already lost its alignment (#203).
+        a["positions"][im.module] = [im.start_line, im.start_column,
+                                     im.end_line, im.end_column]
         if im.name:
             a["names"].add(im.name)
         if im.alias:
@@ -623,6 +640,7 @@ def _project_imports(b: RowBuilder, mod_ref: NodeRef, mod: PyModule,
                     "spellings": sorted(a["spellings"]),
                     "imported_names": sorted(a["names"]) or None,
                     "aliases": sorted(a["aliases"]) or None,
+                    "positions_json": json.dumps(a["positions"], sort_keys=True),
                 }
             ),
         )
@@ -675,7 +693,7 @@ def _project_callable(
         _project_decorator(b, ref, d)
 
     for v in c.local_variables or []:
-        _project_variable(b, file_key, ref, v)
+        _project_variable(b, file_key, ref, v, source)
     for ic in (c.callables or {}).values():
         _project_callable(b, file_key, ref, "PY_DECLARES", ic, externals, sig_to_id,
                           source, base_ref)
@@ -700,12 +718,14 @@ def _project_variable(
     file_key: str,
     owner: NodeRef,
     v: PyVariableDeclaration,
+    source: str,
 ) -> None:
     # ``<owner can:// id>/<name>@<line>`` (#173) — the owner is the module or the
     # callable, so a module-level variable sits under ``<module-id>/`` like every
     # other declaration and the module's prefix purge reaches it.
     var_id = f"{owner.value}/{v.name}@{v.start_line}"
-    ref = b.node(["PyVariable"], "id", var_id, _variable_props(v, var_id, file_key))
+    ref = b.node(["PyVariable"], "id", var_id,
+                 _variable_props(v, var_id, file_key, source))
     b.edge("PY_DECLARES_VAR", owner, ref)
 
 
@@ -737,6 +757,7 @@ def _project_decorator(b: RowBuilder, on: NodeRef, decorator: PyDecorator) -> No
             "keyword_arguments_json": json.dumps(
                 dict(decorator.keyword_arguments or {}), sort_keys=True
             ),
+            **_span_props(decorator.span),
         },
     )
 
@@ -752,6 +773,9 @@ def _module_props(mod: PyModule, file_key: str) -> Props:
             "id": mod.id,
             "file_key": file_key,
             "module_name": mod.module_name,
+            # Always present, never pruned: "" for an empty file, so a consumer can
+            # never confuse "not carried" with "empty" (#202).
+            "source": mod.source or "",
             "content_hash": mod.content_hash,
             "last_modified": mod.last_modified,
             "file_size": mod.file_size,
@@ -760,6 +784,36 @@ def _module_props(mod: PyModule, file_key: str) -> Props:
     )
 
 
+def _span_props(span) -> Props:
+    """The six flattened span properties from a v2 ``Span`` (#202). Lines and columns
+    come straight off the model; ``bytes`` is already utf-8 and is what makes the span
+    sliceable out of ``:PyModule.source``."""
+    if span is None:
+        return {}
+    return {
+        "start_line": span.start[0], "start_column": span.start[1],
+        "end_line": span.end[0], "end_column": span.end[1],
+        "start_byte": span.bytes[0], "end_byte": span.bytes[1],
+    }
+
+
+def _flat_span_props(source: str, start_line: int, start_column: int,
+                     end_line: int, end_column: int) -> Props:
+    """The same six for a model carrying flat ast positions and no ``Span``
+    (:PyAttribute, :PyVariable). The byte pair is computed here rather than left
+    absent, so ``_SPAN`` means one thing on every label that spreads it (#202)."""
+    if start_line < 0 or end_line < 0 or not source:
+        return {}
+    start_column = max(start_column, 0)
+    end_column = max(end_column, 0)
+    lo, hi = byte_offsets(source, start_line, start_column, end_line, end_column)
+    return {
+        "start_line": start_line, "start_column": start_column,
+        "end_line": end_line, "end_column": end_column,
+        "start_byte": lo, "end_byte": hi,
+    }
+
+
 def _span_code(source: str, span) -> str | None:
     """A declaration's text: the owning module's ``source`` sliced by the node's
     utf-8 byte span. Schema v2 stores source once per module, so the graph's
@@ -781,8 +835,8 @@ def _class_props(cl: PyClass, file_key: str, source: str) -> Props:
             "base_classes": list(cl.base_classes or []),
             "decorators": [d.qualified_name or d.name for d in (cl.decorators or [])],
             "docstring": _docstring_of(cl.comments),
-            "start_line": cl.start_line,
-            "end_line": cl.end_line,
+            **(_span_props(cl.span) or {"start_line": cl.start_line,
+                                        "end_line": cl.end_line}),
             "_module": file_key,
             "is_entrypoint": bool(cl.entrypoints),
             "entrypoint_frameworks": sorted({e.framework for e in (cl.entrypoints or [])}),
@@ -801,8 +855,8 @@ def _callable_props(c: PyCallable, file_key: str, source: str) -> Props:
             "cyclomatic_complexity": c.cyclomatic_complexity,
             "code": _span_code(source, c.span),
             "code_start_line": c.code_start_line,
-            "start_line": c.start_line,
-            "end_line": c.end_line,
+            **(_span_props(c.span) or {"start_line": c.start_line,
+                                       "end_line": c.end_line}),
             "docstring": _docstring_of(c.comments),
             "decorators": [d.qualified_name or d.name for d in (c.decorators or [])],
             "modifiers": list(c.modifiers or []),
@@ -823,6 +877,8 @@ def _attribute_props(a: PyClassAttribute, attr_id: str, file_key: str) -> Props:
             "type": a.type,
             "initializer": a.initializer,
             "docstring": _docstring_of(a.comments),
+            # Line-only: PyClassAttribute has no columns, so there is nothing to
+            # derive bytes from. See the note on :PyAttribute in schema.py.
             "start_line": a.start_line,
             "end_line": a.end_line,
             "_module": file_key,
@@ -830,16 +886,21 @@ def _attribute_props(a: PyClassAttribute, attr_id: str, file_key: str) -> Props:
     )
 
 
-def _variable_props(v: PyVariableDeclaration, var_id: str, file_key: str) -> Props:
+def _variable_props(v: PyVariableDeclaration, var_id: str, file_key: str,
+                    source: str) -> Props:
     return prune(
         {
             "id": var_id,
             "name": v.name,
             "type": v.type,
             "initializer": v.initializer,
+            # ``value`` is Optional[Any] and a Neo4j property is a scalar or an array
+            # of scalars, so a dict/list value needs a serialization rather than a raw
+            # put -- always encoded, one shape for every value (#203).
+            "value_json": _stringify_if(v.value) if v.value is not None else None,
             "scope": v.scope,
-            "start_line": v.start_line,
-            "end_line": v.end_line,
+            **_flat_span_props(source, v.start_line, v.start_column,
+                              v.end_line, v.end_column),
             "_module": file_key,
         }
     )

codeanalyzer/neo4j/schema.py

@@ -28,6 +28,13 @@ SCHEMA_VERSION is the contract version: bump MAJOR on a breaking change (renamed
 relationship or key), MINOR on an additive change (new label/rel/property). It is stamped onto
 the :PyApplication node of every emitted graph so any consumer can detect a producer/consumer
 mismatch at runtime.
+
+**The additive-MINOR rule is suspended for the 2.0.0 line.** Per the 2026-09-07 ruling (all three
+analyzers), payload ``schema_version`` and this version both hold at ``2.0.0`` until the 2.0.0 line
+leaves release-candidate, so the additive properties of #202/#203 ship without a bump and are
+detectable only by presence. Consumers gate on the **analyzer version** instead -- the python-sdk
+Neo4j backends carry an analyzer floor and refuse anything below it at attach. The rule above
+resumes at the coordinated re-baseline.
 """
 
 from __future__ import annotations
@@ -61,7 +68,18 @@ class RelType:
 # anchor for the prefix-scoped destructive statements (see ``rows.CAN_NODE``).
 MARKER_LABELS: List[str] = ["PyCanNode"]
 
-_SPAN = {"start_line": "integer", "end_line": "integer"}
+# The flattened span. ``start_column``/``end_column``/``start_byte``/``end_byte``
+# are adopted **verbatim** from codeanalyzer-java#255, which coined them: a term
+# coined twice is permanently wrong under the cross-language parity clause. The
+# byte pair makes every span sliceable out of :PyModule.source -- for the labels
+# whose JSON model carries flat ast positions and no ``Span`` (:PyAttribute,
+# :PyVariable) the projector computes it, so this dict means one thing on every
+# label that spreads it (#202).
+_SPAN = {
+    "start_line": "integer", "end_line": "integer",
+    "start_column": "integer", "end_column": "integer",
+    "start_byte": "integer", "end_byte": "integer",
+}
 
 
 NODE_LABELS: List[NodeLabel] = [
@@ -90,6 +108,10 @@ NODE_LABELS: List[NodeLabel] = [
             "id": "string",
             "file_key": "string",
             "module_name": "string",
+            # The primary text: schema v2 stores source once per module and every
+            # narrower node's text is a byte slice of it. Always present -- an empty
+            # file yields "", so "not carried" is never confusable with "empty" (#202).
+            "source": "string",
             "content_hash": "string",
             "last_modified": "float",
             "file_size": "integer",
@@ -158,7 +180,13 @@ NODE_LABELS: List[NodeLabel] = [
             "type": "string",
             "initializer": "string",
             "docstring": "string",
-            **_SPAN,
+            # The one _SPAN exception: ``PyClassAttribute`` carries start/end LINE only
+            # -- no columns, hence no derivable byte offsets. Emitting a fabricated
+            # column 0 would make the span unsliceable while claiming otherwise, so the
+            # line pair is declared honestly instead. Filed for the JSON model to gain
+            # columns; until then this label is line-granular (#203).
+            "start_line": "integer",
+            "end_line": "integer",
         },
     ),
     NodeLabel(
@@ -170,6 +198,11 @@ NODE_LABELS: List[NodeLabel] = [
             "name": "string",
             "type": "string",
             "initializer": "string",
+            # ``PyVariableDeclaration.value`` -- the literal-evaluated result, always
+            # JSON-encoded because it is ``Optional[Any]`` and a Neo4j property is a
+            # scalar or an array of scalars (the ``arguments_json`` precedent, #203).
+            # ``initializer`` stays the raw source text.
+            "value_json": "string",
             "scope": "string",
             **_SPAN,
         },
@@ -197,6 +230,12 @@ NODE_LABELS: List[NodeLabel] = [
             "return_type": "string",
             "is_constructor_call": "boolean",
             "arguments_json": "string",
+            # What distinguishes overload targets at a resolved call site. Joined
+            # from ``PyCallable.call_sites`` at projection time, since ``BodyNode``
+            # does not carry it in JSON (#203). ``argument_types`` is deliberately
+            # NOT here: it is the legacy field #86 split into ``PyCallArgument``,
+            # already carried as ``arguments_json``.
+            "callee_signature": "string",
             **_SPAN,
         },
     ),
@@ -247,16 +286,26 @@ REL_TYPES: List[RelType] = [
         "PY_IMPORTS",
         ["PyModule"],
         ["PyModule", "PyPackage"],
-        {"spellings": "string[]", "imported_names": "string[]", "aliases": "string[]"},
+        # ``positions_json`` keys on the spelling, not on an index: this edge
+        # pre-aggregates per (module, target) and emits ``spellings`` sorted, so
+        # parallel position arrays have already lost their alignment (#203).
+        {"spellings": "string[]", "imported_names": "string[]", "aliases": "string[]",
+         "positions_json": "string"},
     ),
     RelType(
         "PY_DECORATED_BY",
         ["PyCallable", "PyClass"],
         ["PyDecorator"],
+        # The span rides here, not on :PyDecorator: that node is merged on the
+        # resolved ``qualified_name`` and carries no ``_module``, so it is never
+        # pruned and any per-application fact on it would accumulate across every
+        # project in the database -- the same reason ``expression`` and the
+        # arguments already ride the relationship (#203).
         {
             "expression": "string",
             "positional_arguments": "string[]",
             "keyword_arguments_json": "string",
+            **_SPAN,
         },
     ),
     # Level-3 CPG overlay (-a 3 only): the cross-language dataflow vocabulary,

{codeanalyzer_python-1.5.1.dist-info → codeanalyzer_python-1.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codeanalyzer-python
-Version: 1.5.1
+Version: 1.5.2
 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

{codeanalyzer_python-1.5.1.dist-info → codeanalyzer_python-1.5.2.dist-info}/RECORD

@@ -48,9 +48,9 @@ codeanalyzer/neo4j/__init__.py,sha256=8Ei6uThTOqmul6GhnKoGOjLXJZbyDwF5Jo-8I8NxnA
 codeanalyzer/neo4j/bolt.py,sha256=8l70iGDjY3Kdm-W1sb3b3O1uqLjDrVPYTpXhnkXdZOY,13694
 codeanalyzer/neo4j/cypher.py,sha256=-wledvXVrcLJRtSC5MCn1N3tqgC06rNfPBn0w6POqHo,6239
 codeanalyzer/neo4j/emit.py,sha256=OBCO77TDTaNpqk9Di3JIQzBouLpHPdgoXuPSs44iJuU,3587
-codeanalyzer/neo4j/project.py,sha256=wKvX7C1vamGswzoBRX09BZ1hOm1NJWoSdtQ7UNt2qTE,39102
+codeanalyzer/neo4j/project.py,sha256=gUAmIXLt0agWB1q1OS1Nzvlo1M6rqzzQymoy7lWxTps,42348
 codeanalyzer/neo4j/rows.py,sha256=n_J3NVIusLPsHMjPCWaYvlL5sFm6V-kl_Z6B_BTH8Fk,10140
-codeanalyzer/neo4j/schema.py,sha256=ZRjBxpagBsQrPbD5BbeAZlj3ilTeYe4AsquztRDaH4M,14735
+codeanalyzer/neo4j/schema.py,sha256=0qZ1qJgmutlMHyIjdfD5N9QtA-gwl8Qcgh4NGguQEMs,18089
 codeanalyzer/options/__init__.py,sha256=6NewN0a-1HAEgKcxQjYyVn2WEDLrhax8h3WLgZddeqI,94
 codeanalyzer/options/options.py,sha256=2jDCcs74iSEOhz90LoRGts6PC8yV9IDPVxnLPNmonOA,1609
 codeanalyzer/schema/__init__.py,sha256=hIyz02abUJNPW8yUgguaeKflZjTmOZWbDiKICNBD7yk,4141
@@ -70,9 +70,9 @@ codeanalyzer/syntactic_analysis/symbol_table_builder.py,sha256=eTknBDlUuuQd3JEwb
 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.1.dist-info/METADATA,sha256=Ujo3QIsG8aBykzxm3Mjw_OLCD3b8oaiIrLP1wTvOVD8,44845
-codeanalyzer_python-1.5.1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-codeanalyzer_python-1.5.1.dist-info/entry_points.txt,sha256=v4Vux0Nnx7sOntVk_CH7W9RX6SkIkvR1FQYq73oVlCQ,105
-codeanalyzer_python-1.5.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-codeanalyzer_python-1.5.1.dist-info/licenses/NOTICE,sha256=MdVkNYqHJ20on2FmWvgD4WpMsX5mir33xdyPvTXd0A0,1223
-codeanalyzer_python-1.5.1.dist-info/RECORD,,
+codeanalyzer_python-1.5.2.dist-info/METADATA,sha256=hivDuG8vX-aDD0NW-giMx8A4XXclXcFCtnFR5dYJF2g,44845
+codeanalyzer_python-1.5.2.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+codeanalyzer_python-1.5.2.dist-info/entry_points.txt,sha256=v4Vux0Nnx7sOntVk_CH7W9RX6SkIkvR1FQYq73oVlCQ,105
+codeanalyzer_python-1.5.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+codeanalyzer_python-1.5.2.dist-info/licenses/NOTICE,sha256=MdVkNYqHJ20on2FmWvgD4WpMsX5mir33xdyPvTXd0A0,1223
+codeanalyzer_python-1.5.2.dist-info/RECORD,,