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

codeanalyzer/core.py

@@ -19,6 +19,7 @@ from codeanalyzer.schema import (
     model_validate_json,
 )
 from codeanalyzer.schema.assign_ids import assign_ids
+from codeanalyzer.schema.ids import external_id
 from codeanalyzer.schema.l1_body import populate_l1_body
 from codeanalyzer.schema.l2_callees import backfill_callees
 from codeanalyzer.schema.call_graph_ids import reidentify_call_graph
@@ -564,8 +565,7 @@ class Codeanalyzer:
                 if sig in sig_to_id:
                     continue
                 module, name = sig.rsplit(".", 1) if "." in sig else (None, sig)
-                ext_id = f"{app_id}/@external/{module}/{name}" if module else \
-                    f"{app_id}/@external/{name}"
+                ext_id = external_id(app_id, module, name)
                 sig_to_id[sig] = ext_id
                 externals[ext_id] = PyExternalSymbol(
                     id=ext_id, name=name, module=module

codeanalyzer/neo4j/bolt.py

@@ -41,8 +41,8 @@ Nodes are MERGE-upserted, never blindly deleted, so a declaration another
 MERGE-only.
 
 **Every destructive statement is scoped on the ``can://`` id prefix** (#173). The id is a
-path — ``can://python/<app>/<file>/...`` — so ``id = <module-id> OR id STARTS WITH
-<module-id> + '/'`` is containment, and it is one language, one application and one
+path — ``can://<app>/python/<file>/...`` — so ``id = <module-id> OR id STARTS WITH
+<module-id> + '/'`` is containment, and it is one application, one language and one
 module at once. That is what neither a label anchor nor the retired ``_module`` property
 could give: two python applications sharing ``src/foo.py`` carry identical labels and an
 identical file key, and only the id tells them apart. ``:PyCanNode`` anchors the predicate
@@ -115,10 +115,16 @@ def bolt_writer(rows: GraphRows, cfg: BoltConfig, full_run: bool, eager: bool =
                 s.run(stmt)
 
         # The application anchor. Every destructive statement below is scoped to
-        # ``can://python/<app>/``; an empty application id is refused up front rather
-        # than becoming ``STARTS WITH ''`` (every node in the database).
+        # ``can://<app>/``; an empty application is refused up front rather than
+        # becoming ``STARTS WITH ''`` (every node in the database). The root row is
+        # keyed on its ``can://`` id now, so the name comes off its props — reading
+        # ``n.value`` here would build ``can://can://<app>/``.
         app_name = next(
-            (n.value for n in rows.nodes if n.labels and n.labels[0] == "PyApplication"),
+            (
+                n.props.get("name")
+                for n in rows.nodes
+                if n.labels and n.labels[0] == "PyApplication"
+            ),
             None,
         )
         app_prefix = application_prefix(app_name)
@@ -195,7 +201,7 @@ def bolt_writer(rows: GraphRows, cfg: BoltConfig, full_run: bool, eager: bool =
         _upsert_edges(session, neo4j, edges)
 
         # 6. orphan prune — only safe on a full run (a targeted run can't tell deleted from untargeted).
-        # Scoped to ``can://python/<app>/`` so a full run for application B never deletes
+        # Scoped to ``can://<app>/`` so a full run for application B never deletes
         # application A's modules from a shared database — even when both are python and
         # share a module path.
         if full_run and eager:

codeanalyzer/neo4j/cypher.py

@@ -38,6 +38,7 @@ from codeanalyzer.neo4j.rows import (
     cypher_value,
 )
 from codeanalyzer.neo4j.schema import CONSTRAINTS, INDEXES
+from codeanalyzer.schema.ids import application_id
 
 BATCH = 500
 
@@ -68,17 +69,24 @@ def render_cypher(rows: GraphRows, app_name: str) -> str:
 
 
 def _wipe(app_name: str) -> str:
-    """Everything under ``can://python/<app>/`` plus the application anchor (#173).
-    Scoped by id prefix, so it is one language and one application by construction —
-    a second python app sharing a module path, a sibling analyzer's graph, and the
-    cross-language :Artifact / :Package nodes are all outside it."""
+    """The application root by equality plus everything under ``can://<app>/`` (#173).
+    Scoped by id prefix, so it is one application by construction — a second python
+    app sharing a module path, and a sibling analyzer's :Py* graph, are outside it.
+    :Package nodes (``pkg:`` purls) stay outside too.
+
+    Two things moved with the app-outermost grammar. The root is matched by its
+    ``can://<app>`` id rather than by the free-text ``--app-name``, so two apps
+    sharing a name no longer wipe each other's root; and the app's :Artifact /
+    :ConfigKey nodes are now *inside* the prefix, so the snapshot rebuilds them
+    instead of leaving them to accumulate. That is deliberate, and it is the one
+    behavioural widening here: a cross-language edge into a shared :Artifact is
+    dropped by a python snapshot and restored on that analyzer's next push."""
     prefix = cypher_value(application_prefix(app_name))
-    name = cypher_value(app_name)
+    app_id = cypher_value(application_id(app_name))
     return "\n".join(
         [
-            f"MATCH (x:{CAN_NODE}) WHERE x.id STARTS WITH {prefix}",
+            f"MATCH (x:{CAN_NODE}) WHERE x.id = {app_id} OR x.id STARTS WITH {prefix}",
             "CALL { WITH x DETACH DELETE x } IN TRANSACTIONS OF 1000 ROWS;",
-            f"MATCH (a:PyApplication {{name: {name}}}) DETACH DELETE a;",
         ]
     )
 

codeanalyzer/neo4j/project.py

@@ -49,7 +49,7 @@ from codeanalyzer.schema import (
     PyVariableDeclaration,
 )
 from codeanalyzer.schema import model_dump
-from codeanalyzer.schema.ids import application_id, global_ordinal, purl_pypi
+from codeanalyzer.schema.ids import application_id, external_id, global_ordinal, purl_pypi
 from codeanalyzer.schema.py_schema import PyDecorator
 
 
@@ -60,12 +60,17 @@ def project(app: PyApplication, app_name: str, sig_to_id: dict,
     passes it through so the :PyApplication node carries it as props."""
     b = RowBuilder()
 
+    # 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
+    # no diagnostic. ``name`` survives as a display property.
     app_ref = b.node(
         ["PyApplication"],
-        "name",
-        app_name,
+        "id",
+        application_id(app_name),
         prune(
             {
+                "id": application_id(app_name),
+                "name": app_name,
                 "schema_version": SCHEMA_VERSION,
                 "analyzer_name": analyzer.name if analyzer else None,
                 "analyzer_version": analyzer.version if analyzer else None,
@@ -290,7 +295,7 @@ def _import_ghost(b: RowBuilder, app_can_id: str, name: str) -> NodeRef:
     projected too, both rows collapse onto this one node — correctly, since
     they name the same real-world symbol."""
     return b.node(
-        ["PySymbol", "PyExternal"], "id", f"{app_can_id}/@external/{name}", {"name": name}
+        ["PySymbol", "PyExternal"], "id", external_id(app_can_id, None, name), {"name": name}
     )
 
 
@@ -503,7 +508,7 @@ def _external_ghost(b: RowBuilder, app_can_id: str, signature: str) -> NodeRef:
     ``_home_external_symbols`` uses — ``<app>/@external/<module>/<name>`` — so it
     sits inside the application prefix (#173) and MERGEs with a homed twin."""
     module, name = signature.rsplit(".", 1) if "." in signature else (None, signature)
-    ext_id = f"{app_can_id}/@external/{module}/{name}" if module else f"{app_can_id}/@external/{name}"
+    ext_id = external_id(app_can_id, module, name)
     return b.node(["PySymbol", "PyExternal"], "id", ext_id, prune({"name": name, "module": module}))
 
 

codeanalyzer/neo4j/rows.py

@@ -28,6 +28,8 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Dict, List, Optional, Union
 
+from codeanalyzer.schema.ids import SCHEME, application_id
+
 # A property value: a primitive, or a homogeneous list of primitives.
 Scalar = Union[str, int, float, bool]
 Prop = Union[Scalar, List[str], List[int], List[float], List[bool]]
@@ -57,28 +59,37 @@ class NodeRow:
     module: Optional[str] = None
 
 
-# The marker label on every node keyed by a ``can://python/`` id (#173). It is an
+# The marker label on every node keyed by a ``can://`` id (#173). It is an
 # INDEX ANCHOR, nothing more: Neo4j property indexes are label-scoped, so the
 # prefix predicate ``id STARTS WITH $p`` needs a label to seek on. Safety comes
-# from the prefix, which carries language, application and module.
+# from the prefix, which carries application, language and module.
+#
+# The test is the SCHEME, never a language segment: since the app moved outermost
+# an id no longer begins with the language, and ``can://python/`` now means "the
+# application is called python". Testing that here would have quietly stripped the
+# marker off every graph but one, taking the destructive statements' index — and
+# their reach — with it.
 CAN_NODE = "PyCanNode"
-_PY_CAN_PREFIX = "can://python/"
 
 
 def descendant_prefix(can_id: str) -> str:
     """The prefix that matches a node's descendants and nothing else. The separator
-    is the point: ``can://python/app/src/foo.py`` is also a prefix of
-    ``can://python/app/src/foo.pyX``, so descendants match on ``id + '/'`` and the
+    is the point: ``can://app/python/src/foo.py`` is also a prefix of
+    ``can://app/python/src/foo.pyX``, so descendants match on ``id + '/'`` and the
     node itself by equality."""
     return f"{can_id}/"
 
 
 def application_prefix(app_name: Optional[str]) -> str:
-    """``can://python/<app>/`` — the scope of every destructive statement. Refuses an
-    empty application: ``STARTS WITH ''`` would match every node in the database."""
+    """``can://<app>/`` — the scope of every destructive statement. Refuses an
+    empty application: ``STARTS WITH ''`` would match every node in the database.
+
+    Since the app is the outermost segment this now covers the application's
+    artifacts and config keys too, which the old language-first prefix left
+    outside every scope and so never cleaned up."""
     if not app_name:
         raise ValueError("neo4j: refusing a destructive statement without an application id")
-    return descendant_prefix(f"{_PY_CAN_PREFIX}{app_name}")
+    return descendant_prefix(application_id(app_name))
 
 
 @dataclass
@@ -131,7 +142,7 @@ class RowBuilder:
         node_id = f"{labels[0]} {value}"
         props = dict(props)
         module = props.pop("_module", None)  # lifted off the graph (#173)
-        if key_prop == "id" and value.startswith(_PY_CAN_PREFIX) and CAN_NODE not in labels:
+        if key_prop == "id" and value.startswith(SCHEME) and CAN_NODE not in labels:
             labels = [*labels, CAN_NODE]
         existing = self._nodes.get(node_id)
         if existing is not None:

codeanalyzer/neo4j/schema.py

@@ -57,7 +57,7 @@ class RelType:
 
 
 # Labels layered onto a node in addition to its primary/specific label.
-# ``PyCanNode`` (#173) rides every node keyed by a ``can://python/`` id — an index
+# ``PyCanNode`` (#173) rides every node keyed by a ``can://`` id — an index
 # anchor for the prefix-scoped destructive statements (see ``rows.CAN_NODE``).
 MARKER_LABELS: List[str] = ["PyCanNode"]
 
@@ -68,8 +68,9 @@ NODE_LABELS: List[NodeLabel] = [
     NodeLabel(
         "PyApplication",
         "PyApplication",
-        "name",
+        "id",
         {
+            "id": "string",
             "name": "string",
             "schema_version": "string",
             "analyzer_name": "string",

codeanalyzer/schema/ids.py

@@ -1,17 +1,30 @@
 """Canonical `can://` id construction for schema v2 (durable ids, ≥ callable).
 Ordinal ids (< callable) are `ordinal_id(callable_id, tag)`. Pure functions;
-ids are opaque handles (the <file> segment itself contains '/')."""
+ids are opaque handles (the <file> segment itself contains '/').
+
+The **application is the outermost segment** and the language sits inside it:
+``can://<app>/python/<file>/<type>/<callable-sig>``. So ``can://<app>`` is a
+prefix of every id this analyzer mints for that application — code, externals
+and artifacts alike — which is what the prefix-scoped destructive statements
+(#173) rely on. Nothing may be identified by its *language* prefix any more:
+an application named ``python`` mints ``can://python/python/...``, so a test
+for ``can://python/`` no longer means "a python id"; test the scheme instead."""
 from __future__ import annotations
-from typing import List
+from typing import List, Optional
 
-_SCHEME = "can://python"
+SCHEME = "can://"
+
+# This analyzer's language segment, which sits INSIDE the app rather than above it.
+LANG = "python"
 
 def application_id(app_name: str) -> str:
-    return f"{_SCHEME}/{app_name}"
+    """``can://<app>`` — the application root, and the prefix every id below it shares."""
+    return f"{SCHEME}{app_name}"
 
 def module_id(app_name: str, file_key: str) -> str:
+    """``can://<app>/python/<relative-file-key>`` (separators normalized to ``/``)."""
     rel = file_key.replace("\\", "/").lstrip("./")
-    return f"{application_id(app_name)}/{rel}"
+    return f"{application_id(app_name)}/{LANG}/{rel}"
 
 def child_id(parent_id: str, segment: str) -> str:
     return f"{parent_id}/{segment}"
@@ -23,6 +36,22 @@ def ordinal_id(callable_id: str, tag: str) -> str:
     return f"{callable_id}@{tag}"
 
 
+def external_id(app_id: str, module: Optional[str], name: str) -> str:
+    """``can://<app>/@external/<module>/<name>`` — the home of a call-graph
+    endpoint that is not declared in the symbol table (an imported library or
+    builtin member). ``module`` is ``None`` for a dot-less signature, which drops
+    the segment.
+
+    Language-NEUTRAL, like ``artifact``: ``@external`` sits in the position the
+    language occupies for code nodes, so sibling analyzers over the same ``<app>``
+    name a library symbol identically and it is one node in a merged graph. The
+    cost is real and was accepted deliberately — two analyzers' notions of
+    ``os.getcwd`` are not necessarily the same thing, and merging them says they
+    are. TypeScript's form; java follows it."""
+    base = f"{app_id}/@external"
+    return f"{base}/{module}/{name}" if module else f"{base}/{name}"
+
+
 def global_ordinal(callable_id: str, local_key: str) -> str:
     """The GLOBAL ordinal id of a body node from its LOCAL key: synthetic keys
     (`@entry`, `@formal_in:0`) already carry the `@`; positional keys (`15:2`,
@@ -41,12 +70,13 @@ def stamp_body_ids(callable) -> None:
 
 
 def artifact_id(app_name: str, rel_path: str) -> str:
-    """Language-neutral artifact id: ``can://artifact/<app>/<rel-path>``.
+    """Language-neutral artifact id: ``can://<app>/artifact/<rel-path>``.
 
-    The first segment is a namespace (a language for code nodes, the literal
-    ``artifact`` for files), so sibling analyzers over the same repo emit the
-    same id for the same file."""
-    return f"can://artifact/{app_name}/{rel_path}"
+    ``artifact`` is a reserved segment in the same position the language
+    occupies for code nodes, so sibling analyzers over the same repo (same
+    ``<app>``) still emit the same id for the same file — and, unlike the old
+    ``can://artifact/<app>/...``, it now sits inside the application prefix."""
+    return f"{application_id(app_name)}/artifact/{rel_path}"
 
 
 def config_key_id(artifact_id: str, dotted_key: str) -> str:

codeanalyzer/schema/py_schema.py

@@ -481,7 +481,7 @@ class PyExternalSymbol(BaseModel):
     builtin member. An edge-endpoint id home, not a tree node: keyed in
     ``PyApplication.external_symbols`` by its ``can://…/@external/…`` id."""
 
-    id: str = ""  # can://python/<app>/@external/<module>/<name>
+    id: str = ""  # can://<app>/@external/<module>/<name>
     kind: str = "external"
     name: str  # the member/short name, e.g. "get" for "requests.get"
     module: Optional[str] = None  # best-effort owning module, e.g. "requests"
@@ -510,7 +510,7 @@ class PyArtifact(BaseModel):
     plain data/binary) -- never dropped from the walk. Captured broadly (node
     + verbatim ``source``); *meaning* is extracted narrowly -- only
     ``dependency-manifest`` roles feed ``dependencies`` today. ``id`` is
-    language-neutral (``can://artifact/<app>/<path>``)."""
+    language-neutral (``can://<app>/artifact/<path>``)."""
 
     id: str = ""
     kind: str = "artifact"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codeanalyzer-python
-Version: 1.4.1
+Version: 1.5.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
@@ -517,11 +517,11 @@ just populate more of the same tree:
   "k_limit": 3,                   // access-path depth bound (--graph-field-depth); L3+ only
   "analyzer": { "name": "codeanalyzer-python", "version": "1.0.0" },
   "application": {
-    "id": "can://python/<app>",
+    "id": "can://<app>",
     "kind": "application",
     "symbol_table": {             // relative POSIX path → module
       "pkg/mod.py": {
-        "id": "can://python/<app>/pkg/mod.py",
+        "id": "can://<app>/python/pkg/mod.py",
         "kind": "module",
         "source": "…full file text, stored once per module…",
         "types":     { "<Class>": { "id": "…", "kind": "class", "callables": { /* methods */ } } },
@@ -531,8 +531,8 @@ just populate more of the same tree:
     "call_graph": [ { "src": "can://…/main(a)", "dst": "can://…/helper(x)",
                       "weight": 1, "prov": ["defuse", "jedi"] } ],
     "external_symbols": {         // imported/builtin call targets, keyed by id
-      "can://python/<app>/@external/os/getcwd":
-        { "id": "can://python/<app>/@external/os/getcwd", "kind": "external",
+      "can://<app>/@external/os/getcwd":
+        { "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" } ],
@@ -568,7 +568,7 @@ The application envelope also contains three substrate sections:
 - **`artifacts`** — discovered non-code files (manifests, configs, Docker files, CI workflows,
   packaging files, scripts, docs, and legal files) with extraction status (`none`, `partial`, or
   `full`; default `none`), keyed by relative path; each artifact carries the
-  `can://artifact/<app>/<path>` id namespace. Config files carry extracted `config_keys`
+  `can://<app>/artifact/<path>` id namespace. Config files carry extracted `config_keys`
   (keys, values, namespaces, and references) and `DEFINES_CONFIG` Neo4j edges.
 - **`dependencies`** — declared packages with kind (`runtime`/`dev`/`optional`/`build`), spec,
   locked version, and provenance (`prov`): where each binding came from (manifest file, lock file,
@@ -579,7 +579,7 @@ The application envelope also contains three substrate sections:
 Notable properties:
 
 - **Durable `can://` ids** identify every node at callable granularity and above
-  (`can://python/<app>/<file>/<callable-sig>`); nodes below a callable use ordinal ids
+  (`can://<app>/python/<file>/<callable-sig>`); nodes below a callable use ordinal ids
   (`@entry`, `@exit`, `line:col`, `@formal_in:N`, `line:col/actual_in:N`).
 - **`source` lives once per module**; every node's text is the `module.source[span.bytes]` slice.
 - **Cross-function edges** — `call_graph`, `param_in`, `param_out`, `config_uses` — live at **application** scope;
@@ -701,7 +701,7 @@ RETURN src.id, d.var, d.prov
 
 // interprocedural flow through a parameter (level 4)
 MATCH (a:PyBodyNode)-[:PY_PARAM_IN]->(f:PyBodyNode)
-WHERE f.id STARTS WITH "can://python/myapp/src/api.py"
+WHERE f.id STARTS WITH "can://myapp/python/src/api.py"
 RETURN a.id, f.id
 ```
 
@@ -730,3 +730,25 @@ RETURN f.id, l.version
 ## License
 
 Apache 2.0 — see [LICENSE](./LICENSE).
+
+## Polyglot applications: all languages, or none
+
+A `--emit neo4j` push is **destructive**. It sweeps everything under `can://<app>/` that this
+analyzer marked, then rewrites what it found. Since the id grammar puts the application outermost,
+every analyzer over the same `<app>` shares that prefix — so a push reclaims stale rows belonging to
+*this* analyzer and, in the shared namespaces, sweeps rows a sibling wrote.
+
+For most of what is shared that is harmless: the artifact walk is a whole-repo inventory, so an
+`:Artifact` a sibling wrote is re-created by this push (with a thinner view of it — `roles` falls
+back to `unknown` and its config keys and dependency edges are gone until that sibling pushes
+again). `@external` ghosts are not inventoried that way: they are per-language, so a sibling's
+ghosts are swept and not restored.
+
+**So for an application analysed in more than one language, run every analyzer or none.** Running
+one in isolation leaves the others' derived rows missing until they run again. Running them
+together is always correct, in any order, because the last push restores everything the batch
+swept.
+
+Nothing here corrupts a graph: what is lost is derived and regenerates. But a partial run leaves a
+partial answer, and nothing in the data says so.
+

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

@@ -1,6 +1,6 @@
 codeanalyzer/__init__.py,sha256=BZ3Kuwl-F_F-8H8cepLnVJ4Ku4NNUjjqg0Y6ujPQSsI,108
 codeanalyzer/__main__.py,sha256=o5_9ct61l3T7ryIsag8bz304NabVV-el_ooGD8tnbhA,15968
-codeanalyzer/core.py,sha256=tk_3dz81ECXXv8CEciWTIVfBAHHIfTVCsZte1GAZ080,46620
+codeanalyzer/core.py,sha256=JfSsQEacBiVn38tQP34QWdJqQx7ecE70EXI8obISZN4,46598
 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
@@ -45,21 +45,21 @@ codeanalyzer/entrypoints/rules.yml,sha256=sguICRfDDNGjJPfZz-JSwkI_hzbTJaau1liHV_
 codeanalyzer/jedi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codeanalyzer/jedi/jedi.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codeanalyzer/neo4j/__init__.py,sha256=8Ei6uThTOqmul6GhnKoGOjLXJZbyDwF5Jo-8I8NxnAk,1574
-codeanalyzer/neo4j/bolt.py,sha256=kcBhujHuUst6s1eZD-vARDn0iuKUAxSHrN14nrsKGM8,13472
-codeanalyzer/neo4j/cypher.py,sha256=y2AW9OUAbZJ4TVHkFpHChJU3r_K7q81tTZKt0VNve6g,5677
+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=zoLsr2XGywlZbqnwlYvlhIpgu1jmIvSMTyAgIJZkmeM,38494
-codeanalyzer/neo4j/rows.py,sha256=PMlJEyLVIrKITkkK5TOutIzDgBuKLA1RGAkrQ1HLpZo,9579
-codeanalyzer/neo4j/schema.py,sha256=TyT3-Tu9thfWJTuvRtZ3BAIM4kQk13uUEJ-sgr9YAdE,14716
+codeanalyzer/neo4j/project.py,sha256=gw4qmoIyOy6LabbpmBawvvb7yGEvgDV4fdmoV128eJA,38774
+codeanalyzer/neo4j/rows.py,sha256=n_J3NVIusLPsHMjPCWaYvlL5sFm6V-kl_Z6B_BTH8Fk,10140
+codeanalyzer/neo4j/schema.py,sha256=ZRjBxpagBsQrPbD5BbeAZlj3ilTeYe4AsquztRDaH4M,14735
 codeanalyzer/options/__init__.py,sha256=6NewN0a-1HAEgKcxQjYyVn2WEDLrhax8h3WLgZddeqI,94
 codeanalyzer/options/options.py,sha256=2jDCcs74iSEOhz90LoRGts6PC8yV9IDPVxnLPNmonOA,1609
 codeanalyzer/schema/__init__.py,sha256=hIyz02abUJNPW8yUgguaeKflZjTmOZWbDiKICNBD7yk,4141
 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=gBjpOlx4S_1JULlXoAHGommd5e81D5dwd5JSopYwdo8,2543
+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=lbW7fIRWOdVLH0Ql0yYCYZzaS-iaACBLOuDPmXesjKs,24238
+codeanalyzer/schema/py_schema.py,sha256=Ujre6PoBQZ3DUn9tjoPsqoYBPtAcYW-WI2JphLaMKyU,24231
 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.4.1.dist-info/METADATA,sha256=tmpHTz20bMUPMGvpJp66Guu8NtDqo-SIFso_Sk0BoHI,43485
-codeanalyzer_python-1.4.1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-codeanalyzer_python-1.4.1.dist-info/entry_points.txt,sha256=v4Vux0Nnx7sOntVk_CH7W9RX6SkIkvR1FQYq73oVlCQ,105
-codeanalyzer_python-1.4.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-codeanalyzer_python-1.4.1.dist-info/licenses/NOTICE,sha256=MdVkNYqHJ20on2FmWvgD4WpMsX5mir33xdyPvTXd0A0,1223
-codeanalyzer_python-1.4.1.dist-info/RECORD,,
+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,,