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

codeanalyzer/dataflow/builder.py

@@ -565,6 +565,7 @@ def emit_l4(
             edge = ParamEdge(
                 src=src_im.global_id(e.source_node),
                 dst=dst_im.global_id(e.target_node),
+                var=e.var,
             )
             (app.param_in if e.type == "PARAM_IN" else app.param_out).append(edge)
 

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
@@ -257,17 +269,23 @@ def _project_program_graphs(
     # endpoint functions' identity maps), so they land on the very PyBodyNode ids
     # projected above — a formal_in global id equals _global_ordinal(callee.id,
     # "@formal_in:0"). No dangling references.
+    # `var` (#195): the callee-side formal's variable, set on every edge by the
+    # SDG assembler and carried on `ParamEdge.var`. The catalog declared it and
+    # nothing wrote it, so `r.var` predicates went three-valued across every
+    # call boundary.
     for e in app.param_in or []:
         b.edge(
             "PY_PARAM_IN",
             NodeRef("PyBodyNode", "id", e.src),
             NodeRef("PyBodyNode", "id", e.dst),
+            prune({"var": e.var}),
         )
     for e in app.param_out or []:
         b.edge(
             "PY_PARAM_OUT",
             NodeRef("PyBodyNode", "id", e.src),
             NodeRef("PyBodyNode", "id", e.dst),
+            prune({"var": e.var}),
         )
 
 
@@ -340,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),
                     }
                 ),
             )
@@ -563,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)
 
 
@@ -591,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:
@@ -617,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),
                 }
             ),
         )
@@ -669,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)
@@ -694,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)
 
 
@@ -731,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),
         },
     )
 
@@ -746,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,
@@ -754,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
@@ -775,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 [])}),
@@ -795,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 []),
@@ -817,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,
@@ -824,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/schema/py_schema.py

@@ -171,7 +171,12 @@ class SummaryEdge(BaseModel):
 
 @builder
 class ParamEdge(BaseModel):
+    """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
+    same value codeanalyzer-typescript carries on its `param_in[].var`."""
     src: str; dst: str
+    var: Optional[str] = None
 
 
 @builder

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codeanalyzer-python
-Version: 1.5.0
+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
@@ -535,7 +535,8 @@ just populate more of the same tree:
         { "id": "can://<app>/@external/os/getcwd", "kind": "external",
           "name": "getcwd", "module": "os" }
     },
-    "param_in":  [ { "src": "can://…/main(a)@6:4/actual_in:0", "dst": "can://…/helper(x)@formal_in:0" } ],
+    "param_in":  [ { "src": "can://…/main(a)@6:4/actual_in:0", "dst": "can://…/helper(x)@formal_in:0",
+                     "var": "x" } ],                                    // var = the callee formal
     "param_out": [ { "src": "can://…/helper(x)@formal_out",   "dst": "can://…/main(a)@6:4/actual_out" } ]
   }
 }

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

@@ -13,7 +13,7 @@ codeanalyzer/artifacts/parsers.py,sha256=xOjC53tT0Mv0k7ONGwzl5XUvpBLnZlEcGmyrX5D
 codeanalyzer/dataflow/__init__.py,sha256=HCNOH24rAGLUMG94N9aC-2SsAWSntk3uys7e39ipU5o,1725
 codeanalyzer/dataflow/access_paths.py,sha256=wC8Q9qD-RZzkoFWMVvu_6uNNmYP8z48OGp9h9v3F1d4,23623
 codeanalyzer/dataflow/alias.py,sha256=ZYKY0DiR3GHv6YJr7C001Lode9rZsk6-gxdomUyIvwg,3928
-codeanalyzer/dataflow/builder.py,sha256=kUjI_oBHn5H8cfcSYxj40OHxiqXX-IbxXqahNLgffyQ,32812
+codeanalyzer/dataflow/builder.py,sha256=grzgpl82KzNiwlgdTx60INMxkTZvddT3JzgaBRO4xh4,32839
 codeanalyzer/dataflow/cfg.py,sha256=u5YXJjAaDshdgv-9kWWITbBJFP-MwXKq6hbNh0fhDm8,25307
 codeanalyzer/dataflow/defuse.py,sha256=LrX1ToOZzR79NlAGg5T647UAFkpiEqEnT7t0K5RXOiI,4377
 codeanalyzer/dataflow/dominance.py,sha256=X7Ki1QRdVqaseYsJtiUL7m9MbcC2WHEv9b8bczSLFUA,5086
@@ -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=gw4qmoIyOy6LabbpmBawvvb7yGEvgDV4fdmoV128eJA,38774
+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
@@ -59,7 +59,7 @@ codeanalyzer/schema/call_graph_ids.py,sha256=mWAhJDBsW8i-siJiINOHCXEm4qM6F_5se9-
 codeanalyzer/schema/ids.py,sha256=YuioNK3Y-M2NcCBiGH4AB4rDezlqu6ycNO0R3O-Jxho,4388
 codeanalyzer/schema/l1_body.py,sha256=_sca0mTkMRb-5lasep87faGjDxZJd9jGB0hmBx3uCgk,1757
 codeanalyzer/schema/l2_callees.py,sha256=CTcBeGoO04DstDC6h-1sHMbbIrHDEOMxP01U9VLBcfc,2327
-codeanalyzer/schema/py_schema.py,sha256=Ujre6PoBQZ3DUn9tjoPsqoYBPtAcYW-WI2JphLaMKyU,24231
+codeanalyzer/schema/py_schema.py,sha256=4xJto32nWqHx0dkge4qHsV2JZSjbyv4ojnqpyBm78sQ,24588
 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=bSn1rCun28OQqSd2NOc9aVBSm47Gt9Iul4r_gwfqO1w,64930
@@ -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.0.dist-info/METADATA,sha256=X4LXZPtqeXauN-M0hAsMBJCjJxqgOTeCj_KtYOBTgtI,44750
-codeanalyzer_python-1.5.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-codeanalyzer_python-1.5.0.dist-info/entry_points.txt,sha256=v4Vux0Nnx7sOntVk_CH7W9RX6SkIkvR1FQYq73oVlCQ,105
-codeanalyzer_python-1.5.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-codeanalyzer_python-1.5.0.dist-info/licenses/NOTICE,sha256=MdVkNYqHJ20on2FmWvgD4WpMsX5mir33xdyPvTXd0A0,1223
-codeanalyzer_python-1.5.0.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,,