codeanalyzer-python 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

codeanalyzer/__main__.py

@@ -1,3 +1,4 @@
+from importlib.metadata import version as _pkg_version, PackageNotFoundError
 from pathlib import Path
 from typing import Optional, Annotated
 
@@ -10,7 +11,32 @@ from codeanalyzer.schema import model_dump_json
 from codeanalyzer.options import AnalysisOptions, EmitTarget, ShardStrategy
 
 
+def _version_callback(value: bool) -> None:
+    """Print the installed ``codeanalyzer-python`` version and exit.
+
+    Eager so it fires before the rest of the CLI callback (no -i/--input
+    required). Reads the version from package metadata so it always reflects
+    what is actually installed rather than a hardcoded string."""
+    if not value:
+        return
+    try:
+        installed = _pkg_version("codeanalyzer-python")
+    except PackageNotFoundError:
+        installed = "unknown"
+    typer.echo(f"canpy {installed}")
+    raise typer.Exit()
+
+
 def main(
+    version: Annotated[
+        Optional[bool],
+        typer.Option(
+            "--version",
+            help="Show the canpy version and exit.",
+            callback=_version_callback,
+            is_eager=True,
+        ),
+    ] = None,
     input: Annotated[
         Optional[Path],
         typer.Option(

codeanalyzer/core.py

@@ -26,9 +26,11 @@ from codeanalyzer.semantic_analysis.call_graph import (
 )
 from codeanalyzer.semantic_analysis.pycg import PyCG, PyCGExceptions
 from codeanalyzer.syntactic_analysis.exceptions import SymbolTableBuilderRayError
+from codeanalyzer.syntactic_analysis.import_resolver import resolve_imports
 from codeanalyzer.syntactic_analysis.symbol_table_builder import SymbolTableBuilder
 from codeanalyzer.utils import ProgressBar
 from codeanalyzer.options import AnalysisOptions
+from codeanalyzer.provenance import analyzer_info, repository_info
 
 @ray.remote
 def _process_file_with_ray(py_file: Union[Path, str], project_dir: Union[Path, str], virtualenv: Union[Path, str, None]) -> Dict[str, PyModule]:
@@ -411,8 +413,8 @@ class Codeanalyzer:
         Uses caching to avoid re-analyzing unchanged files.
         """
         cache_file = self.cache_dir / "analysis_cache.json"
-        
-        # Try to load existing cached analysis 
+
+        # Try to load existing cached analysis
         cached_pyapplication = None
         if not self.rebuild_analysis and cache_file.exists():
             try:
@@ -422,6 +424,12 @@ class Codeanalyzer:
                 logger.warning(f"Failed to load cache: {e}. Rebuilding analysis.")
                 cached_pyapplication = None
 
+        if cached_pyapplication is not None and not self._cache_analyzer_matches(
+            cached_pyapplication, analyzer_info(self.analysis_level).version
+        ):
+            logger.info("Analysis cache written by a different analyzer version; rebuilding.")
+            cached_pyapplication = None
+
         # Build symbol table from cached application if available (if no available, the build a new one)
         symbol_table = self._build_symbol_table(cached_pyapplication.symbol_table if cached_pyapplication else {})
 
@@ -454,12 +462,35 @@ class Codeanalyzer:
             .external_symbols(external_symbols)
             .build()
         )
-        
+
+        # Every run re-resolves import spellings against the analyzed module
+        # set -- pure and cheap; cached modules from older caches default to
+        # resolved_module=None and get stamped here (issue #82).
+        resolve_imports(app, self.project_dir)
+
+        # Single choke point for provenance: every produced app (fresh symbol
+        # table or reused-from-cache) passes through here before being cached
+        # or returned, so analyzer/repository always reflect *this* run/checkout
+        # even when the symbol table itself came from the on-disk cache.
+        app.analyzer = analyzer_info(self.analysis_level)
+        app.repository = repository_info(self.project_dir)
+
         # Save to cache
         self._save_analysis_cache(app, cache_file)
         
         return app
 
+    @staticmethod
+    def _cache_analyzer_matches(cached_app: Optional[PyApplication], current_version: str) -> bool:
+        """A cache written by another analyzer version (or before versions were
+        recorded) may lack fields the current models populate — pydantic fills
+        silent defaults, which would masquerade as analyzed absence."""
+        return (
+            cached_app is not None
+            and cached_app.analyzer is not None
+            and cached_app.analyzer.version == current_version
+        )
+
     def _load_pyapplication_from_cache(self, cache_file: Path) -> PyApplication:
         """Load cached analysis from file.
         

codeanalyzer/neo4j/__init__.py

@@ -19,7 +19,7 @@ plus the two writers (cypher snapshot / bolt incremental). Nothing here runs
 unless ``--emit neo4j`` (or ``--emit schema``) is selected.
 """
 from codeanalyzer.neo4j.bolt import BoltConfig, bolt_writer
-from codeanalyzer.neo4j.catalog import (
+from codeanalyzer.neo4j.schema import (
     MARKER_LABELS,
     NODE_LABELS,
     REL_TYPES,

codeanalyzer/neo4j/emit.py

@@ -28,7 +28,7 @@ from pathlib import Path
 from typing import Optional
 
 from codeanalyzer.neo4j.bolt import BoltConfig, bolt_writer
-from codeanalyzer.neo4j.catalog import build_schema_document
+from codeanalyzer.neo4j.schema import build_schema_document
 from codeanalyzer.neo4j.cypher import render_cypher
 from codeanalyzer.neo4j.project import project
 from codeanalyzer.options import AnalysisOptions
@@ -38,7 +38,7 @@ from codeanalyzer.utils import logger
 
 def emit_schema(output: Optional[Path]) -> None:
     """Emit the Neo4j schema contract (``schema.json``) — a static artifact derived
-    from the in-repo catalog, independent of any analyzed project. With no
+    from the in-repo schema, independent of any analyzed project. With no
     ``output`` it prints to stdout."""
     doc = json.dumps(build_schema_document(), indent=2) + "\n"
     if output is None:

codeanalyzer/neo4j/project.py

@@ -36,7 +36,7 @@ import json
 from pathlib import Path
 from typing import Any, List, Optional
 
-from codeanalyzer.neo4j.catalog import SCHEMA_VERSION
+from codeanalyzer.neo4j.schema import SCHEMA_VERSION
 from codeanalyzer.neo4j.rows import GraphRows, NodeRef, Props, RowBuilder, prune
 from codeanalyzer.schema import (
     PyApplication,
@@ -53,10 +53,26 @@ from codeanalyzer.schema.py_schema import PyCallsite
 def project(app: PyApplication, app_name: str) -> GraphRows:
     b = RowBuilder()
 
-    app_ref = b.node(["PyApplication"], "name", app_name, {"schema_version": SCHEMA_VERSION})
+    app_ref = b.node(
+        ["PyApplication"],
+        "name",
+        app_name,
+        prune(
+            {
+                "schema_version": SCHEMA_VERSION,
+                "analyzer_name": app.analyzer.name if app.analyzer else None,
+                "analyzer_version": app.analyzer.version if app.analyzer else None,
+                "repo_uri": app.repository.uri if app.repository else None,
+                "source_revision": app.repository.revision if app.repository else None,
+                "repo_dirty": app.repository.dirty if app.repository else None,
+            }
+        ),
+    )
 
     for file_key, mod in app.symbol_table.items():
-        mod_ref = b.node(["PyModule"], "file_key", file_key, _module_props(mod, file_key))
+        mod_ref = b.node(
+            ["PyModule"], "file_key", file_key, _module_props(mod, file_key)
+        )
         b.edge("PY_HAS_MODULE", app_ref, mod_ref)
         _project_module_body(b, file_key, mod_ref, mod)
 
@@ -66,7 +82,9 @@ def project(app: PyApplication, app_name: str) -> GraphRows:
     for e in app.call_graph:
         src = _call_endpoint(b, e.source, externals)
         tgt = _call_endpoint(b, e.target, externals)
-        b.edge("PY_CALLS", src, tgt, _call_edge_props(e.weight, list(e.provenance or [])))
+        b.edge(
+            "PY_CALLS", src, tgt, _call_edge_props(e.weight, list(e.provenance or []))
+        )
 
     return b.finish()
 
@@ -86,9 +104,18 @@ def _call_endpoint(b: RowBuilder, signature: str, externals: dict) -> NodeRef:
     ext = externals.get(signature)
     if ext is None and b.has_key("PySymbol", signature):
         return _sym(signature)
-    name = ext.name if ext is not None else (signature.rsplit(".", 1)[-1] if "." in signature else signature)
+    name = (
+        ext.name
+        if ext is not None
+        else (signature.rsplit(".", 1)[-1] if "." in signature else signature)
+    )
     module = ext.module if ext is not None else None
-    return b.node(["PySymbol", "PyExternal"], "signature", signature, prune({"name": name, "module": module}))
+    return b.node(
+        ["PySymbol", "PyExternal"],
+        "signature",
+        signature,
+        prune({"name": name, "module": module}),
+    )
 
 
 # ----------------------------------------------------------------------------------------------
@@ -96,7 +123,9 @@ def _call_endpoint(b: RowBuilder, signature: str, externals: dict) -> NodeRef:
 # ----------------------------------------------------------------------------------------------
 
 
-def _project_module_body(b: RowBuilder, file_key: str, mod_ref: NodeRef, mod: PyModule) -> None:
+def _project_module_body(
+    b: RowBuilder, file_key: str, mod_ref: NodeRef, mod: PyModule
+) -> None:
     for fn in (mod.functions or {}).values():
         _project_callable(b, file_key, mod_ref, "PY_DECLARES", fn)
     for cl in (mod.classes or {}).values():
@@ -107,25 +136,47 @@ def _project_module_body(b: RowBuilder, file_key: str, mod_ref: NodeRef, mod: Py
 
 
 def _project_imports(b: RowBuilder, mod_ref: NodeRef, mod: PyModule) -> None:
-    # Per-target-module aggregation: collapse all bindings for a given imported
-    # module into one PY_IMPORTS edge to a shared :PyPackage node.
+    # At most one PY_IMPORTS edge per (module, target) pair -- mirrors PY_CALLS,
+    # which pre-aggregates for the same reason: both writers MERGE edges on
+    # (type, from, to) and SET their props, so a second row for the same pair
+    # would silently overwrite the first in Neo4j instead of adding an edge.
+    # Buckets key on the edge's target identity (the resolved module, or the
+    # spelling itself for unresolved/external imports), so the SAME target
+    # imported under different spellings (``from pkg import util``,
+    # ``from . import util as u``, ``from .util import helper``) collapses
+    # onto one edge; the raw spellings ride along as a ``spellings`` array.
+    # Resolved internal imports point at the real :PyModule; externals keep
+    # the shared :PyPackage. Unresolved *relative* spellings (".", ".foo")
+    # name no package -- they are dropped from the graph (the spelling
+    # survives in analysis.json), instead of minting bogus
+    # :PyPackage{name: "."} nodes.
     agg: dict = {}
     for im in mod.imports or []:
         if not im.module:
-            continue  # relative `from . import x` — no resolvable package
-        a = agg.setdefault(im.module, {"names": set(), "aliases": set()})
+            continue
+        if im.resolved_module is None and im.module.startswith("."):
+            continue
+        key = im.resolved_module or im.module
+        a = agg.setdefault(
+            key, {"spellings": set(), "names": set(), "aliases": set(), "resolved": im.resolved_module}
+        )
+        a["spellings"].add(im.module)
         if im.name:
             a["names"].add(im.name)
         if im.alias:
             a["aliases"].add(im.alias)
-    for module_name, a in agg.items():
-        pkg = b.node(["PyPackage"], "name", module_name, {})
+    for key, a in agg.items():
+        if a["resolved"] is not None:
+            target = NodeRef("PyModule", "file_key", a["resolved"])
+        else:
+            target = b.node(["PyPackage"], "name", key, {})
         b.edge(
             "PY_IMPORTS",
             mod_ref,
-            pkg,
+            target,
             prune(
                 {
+                    "spellings": sorted(a["spellings"]),
                     "imported_names": sorted(a["names"]) or None,
                     "aliases": sorted(a["aliases"]) or None,
                 }
@@ -141,7 +192,9 @@ def _project_imports(b: RowBuilder, mod_ref: NodeRef, mod: PyModule) -> None:
 def _project_class(
     b: RowBuilder, file_key: str, parent: NodeRef, parent_rel: str, cl: PyClass
 ) -> None:
-    ref = b.node(["PySymbol", "PyClass"], "signature", cl.signature, _class_props(cl, file_key))
+    ref = b.node(
+        ["PySymbol", "PyClass"], "signature", cl.signature, _class_props(cl, file_key)
+    )
     b.edge(parent_rel, parent, ref)
 
     for base in cl.base_classes or []:
@@ -158,7 +211,12 @@ def _project_class(
 def _project_callable(
     b: RowBuilder, file_key: str, owner: NodeRef, owner_rel: str, c: PyCallable
 ) -> None:
-    ref = b.node(["PySymbol", "PyCallable"], "signature", c.signature, _callable_props(c, file_key))
+    ref = b.node(
+        ["PySymbol", "PyCallable"],
+        "signature",
+        c.signature,
+        _callable_props(c, file_key),
+    )
     b.edge(owner_rel, owner, ref)
 
     for d in c.decorators or []:
@@ -166,7 +224,9 @@ def _project_callable(
 
     for s in c.call_sites or []:
         # Key off the relative file (a call site lives in its callable's file) so ids stay portable.
-        cs_id = f"{file_key}#{s.start_line}:{s.start_column}-{s.end_line}:{s.end_column}"
+        cs_id = (
+            f"{file_key}#{s.start_line}:{s.start_column}-{s.end_line}:{s.end_column}"
+        )
         cs = b.node(["PyCallSite"], "id", cs_id, _call_site_props(s, file_key))
         b.edge("PY_HAS_CALLSITE", ref, cs)
         if s.callee_signature:
@@ -189,7 +249,11 @@ def _project_attribute(
 
 
 def _project_variable(
-    b: RowBuilder, file_key: str, owner: NodeRef, owner_id: str, v: PyVariableDeclaration
+    b: RowBuilder,
+    file_key: str,
+    owner: NodeRef,
+    owner_id: str,
+    v: PyVariableDeclaration,
 ) -> None:
     var_id = f"{owner_id}#{v.name}@{v.start_line}"
     ref = b.node(["PyVariable"], "id", var_id, _variable_props(v, var_id, file_key))
@@ -258,6 +322,7 @@ def _attribute_props(a: PyClassAttribute, attr_id: str, file_key: str) -> Props:
             "id": attr_id,
             "name": a.name,
             "type": a.type,
+            "initializer": a.initializer,
             "docstring": _docstring_of(a.comments),
             "start_line": a.start_line,
             "end_line": a.end_line,
@@ -290,6 +355,7 @@ def _call_site_props(s: PyCallsite, file_key: str) -> Props:
             "receiver_expr": s.receiver_expr,
             "receiver_type": s.receiver_type,
             "argument_types": list(s.argument_types or []),
+            "arguments_json": _stringify_if(s.arguments),
             "return_type": s.return_type,
             "callee_signature": s.callee_signature,
             "is_constructor_call": s.is_constructor_call,

codeanalyzer/neo4j/schema.py

@@ -14,26 +14,272 @@
 # limitations under the License.
 ################################################################################
 
-"""The Cypher DDL — uniqueness constraints and indexes — shared by both writers.
-Run BEFORE any load so MERGE uses an index seek (not a label scan) and the
-identity invariant is enforced by the database. Every statement is idempotent
-(``IF NOT EXISTS``).
 """
-from typing import List
-
-CONSTRAINTS: List[str] = [
-    "CREATE CONSTRAINT py_symbol_sig IF NOT EXISTS FOR (s:PySymbol) REQUIRE s.signature IS UNIQUE",
-    "CREATE CONSTRAINT py_app_name IF NOT EXISTS FOR (a:PyApplication) REQUIRE a.name IS UNIQUE",
-    "CREATE CONSTRAINT py_module_key IF NOT EXISTS FOR (m:PyModule) REQUIRE m.file_key IS UNIQUE",
-    "CREATE CONSTRAINT py_package_name IF NOT EXISTS FOR (p:PyPackage) REQUIRE p.name IS UNIQUE",
-    "CREATE CONSTRAINT py_decorator_name IF NOT EXISTS FOR (d:PyDecorator) REQUIRE d.name IS UNIQUE",
-    "CREATE CONSTRAINT py_callsite_id IF NOT EXISTS FOR (c:PyCallSite) REQUIRE c.id IS UNIQUE",
-    "CREATE CONSTRAINT py_attribute_id IF NOT EXISTS FOR (a:PyAttribute) REQUIRE a.id IS UNIQUE",
-    "CREATE CONSTRAINT py_variable_id IF NOT EXISTS FOR (v:PyVariable) REQUIRE v.id IS UNIQUE",
+The declarative Neo4j schema — the single in-repo source of truth for the graph contract: node
+labels with their keys and typed properties, relationship types and their endpoints, and the
+Cypher DDL (uniqueness constraints + indexes). The constraints are DERIVED from the node labels
+(one per distinct mergeLabel/key) so a new label brings its own constraint — there is no second
+list to keep in sync. `--emit schema` serializes all of this to a machine-readable schema.json,
+and the conformance test (``test/test_neo4j_schema.py``) asserts the real emitter never produces a
+label / relationship / property that isn't declared here — so this file cannot silently drift
+from :mod:`codeanalyzer.neo4j.project`.
+
+SCHEMA_VERSION is the contract version: bump MAJOR on a breaking change (renamed/removed label,
+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.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List
+
+SCHEMA_VERSION = "1.2.0"
+
+# PropType ∈ {"string", "integer", "float", "boolean", "string[]", "integer[]"}.
+
+
+@dataclass
+class NodeLabel:
+    label: str  # the specific label (also the catalog key)
+    merge_label: str  # the label the uniqueness constraint / MERGE is on
+    key: str
+    properties: Dict[str, str]
+
+
+@dataclass
+class RelType:
+    type: str
+    from_labels: List[str]
+    to_labels: List[str]
+    properties: Dict[str, str] = field(default_factory=dict)
+
+
+# Labels layered onto a node in addition to its primary/specific label.
+MARKER_LABELS: List[str] = []
+
+_SPAN = {"start_line": "integer", "end_line": "integer"}
+
+
+NODE_LABELS: List[NodeLabel] = [
+    NodeLabel(
+        "PyApplication",
+        "PyApplication",
+        "name",
+        {
+            "name": "string",
+            "schema_version": "string",
+            "analyzer_name": "string",
+            "analyzer_version": "string",
+            "repo_uri": "string",
+            "source_revision": "string",
+            "repo_dirty": "boolean",
+        },
+    ),
+    NodeLabel(
+        "PyModule",
+        "PyModule",
+        "file_key",
+        {
+            "file_key": "string",
+            "module_name": "string",
+            "content_hash": "string",
+            "last_modified": "float",
+            "file_size": "integer",
+            "_module": "string",
+        },
+    ),
+    NodeLabel(
+        "PyClass",
+        "PySymbol",
+        "signature",
+        {
+            "signature": "string",
+            "name": "string",
+            "code": "string",
+            "base_classes": "string[]",
+            "docstring": "string",
+            **_SPAN,
+            "_module": "string",
+        },
+    ),
+    NodeLabel(
+        "PyCallable",
+        "PySymbol",
+        "signature",
+        {
+            "signature": "string",
+            "name": "string",
+            "path": "string",
+            "return_type": "string",
+            "cyclomatic_complexity": "integer",
+            "code": "string",
+            "code_start_line": "integer",
+            **_SPAN,
+            "docstring": "string",
+            "decorators": "string[]",
+            "parameters_json": "string",
+            "accessed_symbols_json": "string",
+            "_module": "string",
+        },
+    ),
+    NodeLabel(
+        "PyExternal",
+        "PySymbol",
+        "signature",
+        {"signature": "string", "name": "string", "module": "string"},
+    ),
+    NodeLabel("PyPackage", "PyPackage", "name", {"name": "string"}),
+    NodeLabel(
+        "PyDecorator",
+        "PyDecorator",
+        "name",
+        {"name": "string"},
+    ),
+    NodeLabel(
+        "PyCallSite",
+        "PyCallSite",
+        "id",
+        {
+            "id": "string",
+            "method_name": "string",
+            "receiver_expr": "string",
+            "receiver_type": "string",
+            "argument_types": "string[]",
+            "arguments_json": "string",
+            "return_type": "string",
+            "callee_signature": "string",
+            "is_constructor_call": "boolean",
+            "start_line": "integer",
+            "start_column": "integer",
+            "end_line": "integer",
+            "end_column": "integer",
+            "_module": "string",
+        },
+    ),
+    NodeLabel(
+        "PyAttribute",
+        "PyAttribute",
+        "id",
+        {
+            "id": "string",
+            "name": "string",
+            "type": "string",
+            "initializer": "string",
+            "docstring": "string",
+            **_SPAN,
+            "_module": "string",
+        },
+    ),
+    NodeLabel(
+        "PyVariable",
+        "PyVariable",
+        "id",
+        {
+            "id": "string",
+            "name": "string",
+            "type": "string",
+            "initializer": "string",
+            "scope": "string",
+            **_SPAN,
+            "_module": "string",
+        },
+    ),
 ]
 
+_DECL_TARGETS = ["PyClass", "PyCallable"]
+
+
+REL_TYPES: List[RelType] = [
+    RelType("PY_HAS_MODULE", ["PyApplication"], ["PyModule"]),
+    RelType("PY_DECLARES", ["PyModule", "PyClass", "PyCallable"], _DECL_TARGETS),
+    RelType("PY_HAS_METHOD", ["PyClass"], ["PyCallable"]),
+    RelType("PY_HAS_ATTRIBUTE", ["PyClass"], ["PyAttribute"]),
+    RelType("PY_DECLARES_VAR", ["PyModule", "PyCallable"], ["PyVariable"]),
+    RelType("PY_HAS_CALLSITE", ["PyCallable"], ["PyCallSite"]),
+    RelType("PY_RESOLVES_TO", ["PyCallSite"], ["PyCallable", "PyExternal"]),
+    RelType(
+        "PY_CALLS",
+        ["PyCallable", "PyExternal"],
+        ["PyCallable", "PyExternal"],
+        {"weight": "integer", "provenance": "string[]"},
+    ),
+    RelType("PY_EXTENDS", ["PyClass"], ["PyClass"]),
+    RelType(
+        "PY_IMPORTS",
+        ["PyModule"],
+        ["PyModule", "PyPackage"],
+        {"spellings": "string[]", "imported_names": "string[]", "aliases": "string[]"},
+    ),
+    RelType("PY_DECORATED_BY", ["PyCallable"], ["PyDecorator"]),
+]
+
+
+def uniqueness_constraints() -> list[str]:
+    """One uniqueness constraint per distinct (merge_label, key)."""
+    seen: set[tuple[str, str]] = set()
+    out: list[str] = []
+
+    for node in NODE_LABELS:
+        identifier = (node.merge_label, node.key)
+        if identifier in seen:
+            continue
+
+        seen.add(identifier)
+        out.append(
+            f"CREATE CONSTRAINT {node.merge_label.lower()}_{node.key} "
+            f"IF NOT EXISTS FOR (x:{node.merge_label}) "
+            f"REQUIRE x.{node.key} IS UNIQUE"
+        )
+
+    return out
+
+
+CONSTRAINTS: List[str] = uniqueness_constraints()
+
 INDEXES: List[str] = [
     "CREATE INDEX py_callable_name IF NOT EXISTS FOR (c:PyCallable) ON (c.name)",
     "CREATE INDEX py_class_name IF NOT EXISTS FOR (c:PyClass) ON (c.name)",
     "CREATE FULLTEXT INDEX py_code_fts IF NOT EXISTS FOR (c:PyCallable) ON EACH [c.code, c.docstring]",
 ]
+
+
+@dataclass
+class SchemaDocument:
+    schema_version: str
+    generator: str
+    marker_labels: List[str]
+    node_labels: List[NodeLabel]
+    relationship_types: List[RelType]
+    constraints: List[str]
+    indexes: List[str]
+
+
+def build_schema_document() -> dict:
+    """Build the full machine-readable schema document emitted by ``--emit schema``."""
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "generator": "codeanalyzer-python",
+        "marker_labels": list(MARKER_LABELS),
+        "node_labels": [
+            {
+                "label": n.label,
+                "merge_label": n.merge_label,
+                "key": n.key,
+                "properties": n.properties,
+            }
+            for n in NODE_LABELS
+        ],
+        "relationship_types": [
+            {
+                "type": r.type,
+                "from": r.from_labels,
+                "to": r.to_labels,
+                "properties": r.properties,
+            }
+            for r in REL_TYPES
+        ],
+        "constraints": list(CONSTRAINTS),
+        "indexes": list(INDEXES),
+    }