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

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),
+    }

codeanalyzer/options/__init__.py

@@ -1,3 +1,3 @@
-from .options import AnalysisOptions, EmitTarget, OutputFormat
+from .options import AnalysisOptions, EmitTarget, OutputFormat, ShardStrategy
 
-__all__ = ["AnalysisOptions", "EmitTarget", "OutputFormat"]
+__all__ = ["AnalysisOptions", "EmitTarget", "OutputFormat", "ShardStrategy"]

codeanalyzer/options/options.py

@@ -23,6 +23,20 @@ class EmitTarget(str, Enum):
     SCHEMA = "schema"
 
 
+class ShardStrategy(str, Enum):
+    """How ``--pycg-shard`` groups files into shards (level 2 only).
+
+    - ``jedi``    : partition the Jedi module-dependency graph (strongly-
+                    connected-component condensation + Louvain) so tightly-
+                    coupled modules co-compute and few call edges are severed
+                    between shards. Import cycles are never split.
+    - ``package`` : legacy one-shard-per-package-directory grouping.
+    """
+
+    JEDI = "jedi"
+    PACKAGE = "package"
+
+
 @dataclass
 class AnalysisOptions:
     input: Path
@@ -34,7 +48,7 @@ class AnalysisOptions:
     neo4j_user: str = "neo4j"
     neo4j_password: str = "neo4j"
     neo4j_database: Optional[str] = None
-    using_codeql: bool = False
+    analysis_level: int = 1
     using_ray: bool = False
     rebuild_analysis: bool = False
     skip_tests: bool = True
@@ -43,3 +57,8 @@ class AnalysisOptions:
     cache_dir: Optional[Path] = None
     clear_cache: bool = False
     verbosity: int = 0
+    pycg_shard: bool = False
+    pycg_shard_ceiling: int = 100
+    pycg_shard_timeout: int = 120
+    pycg_shard_strategy: ShardStrategy = ShardStrategy.JEDI
+    pycg_max_iter: int = 50

codeanalyzer/provenance.py

@@ -0,0 +1,61 @@
+"""Provenance capture: repository (git) and analyzer identity for a snapshot.
+
+Runs git only as a subprocess query against the analyzed project directory —
+never mutates anything. Absence of git (no repo, no binary) degrades to None.
+"""
+from __future__ import annotations
+
+import subprocess
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+from pathlib import Path
+from typing import Optional, Union
+from urllib.parse import urlsplit, urlunsplit
+
+from codeanalyzer.schema.py_schema import PyAnalyzerInfo, PyRepositoryInfo
+
+
+def _strip_userinfo(uri: str) -> str:
+    """Drop credentials from URL-style remotes; scp-style git@host:path is a
+    username, not a secret, and parses with no netloc — left intact."""
+    parts = urlsplit(uri)
+    if parts.netloc and "@" in parts.netloc:
+        return urlunsplit(parts._replace(netloc=parts.netloc.rpartition("@")[2]))
+    return uri
+
+
+def _git(project_dir: Union[Path, str], *args: str) -> Optional[str]:
+    """One git query; None on any failure (no repo, no git, timeout)."""
+    try:
+        result = subprocess.run(
+            ["git", "-C", str(project_dir), *args],
+            capture_output=True, text=True, timeout=10, check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if result.returncode != 0:
+        return None
+    return result.stdout.strip()
+
+
+def repository_info(project_dir: Union[Path, str]) -> Optional[PyRepositoryInfo]:
+    """Git provenance of ``project_dir``, or None when it isn't a git checkout."""
+    revision = _git(project_dir, "rev-parse", "HEAD")
+    if not revision:
+        return None
+    raw_uri = _git(project_dir, "remote", "get-url", "origin")
+    uri = _strip_userinfo(raw_uri) if raw_uri else None
+    status = _git(project_dir, "status", "--porcelain", "--untracked-files=no")
+    return PyRepositoryInfo(uri=uri, revision=revision, dirty=bool(status))
+
+
+def analyzer_info(analysis_level: int) -> PyAnalyzerInfo:
+    """Identity + configuration of this analyzer run."""
+    try:
+        version = _pkg_version("codeanalyzer-python")
+    except PackageNotFoundError:
+        version = "unknown"
+    return PyAnalyzerInfo(
+        name="codeanalyzer-python",
+        version=version,
+        config={"analysis_level": analysis_level},
+    )