hypergumbo-lang-scip-python 8.1.0__py3-none-any.whl

hypergumbo_lang_scip_python/__init__.py

@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+"""Hypergumbo SCIP-backed Python analyzer (scip-python / pyright), WI-nanom.
+
+The second opt-in fidelity backend and the first that executes nothing from
+the analysed repository. Its parts mirror ``hypergumbo_lang_rust_analyzer``:
+
+- ``invoke.py`` shells out to ``scip-python index`` to produce a SCIP blob.
+- ``translate.py`` turns that blob into ``(symbols, edges)`` through the
+  shared importer, plus the one thing the Rust arm never did: external
+  callees keep the receiver's MODULE.
+- ``gate.py`` answers "did the user ask?" — flag > environment > config
+  tiers (a preference, ADR-0045 ruling 5) — and whether the binary is there.
+- ``analyzer.py`` registers ``scip_python`` beside the ``python`` analyzer
+  with the merge anchor the ADR-0057 pass pairs on.
+"""
+from hypergumbo_lang_scip_python.gate import should_use_scip_python_backend
+from hypergumbo_lang_scip_python.invoke import (
+    ScipPythonError,
+    ScipPythonInvocationFailed,
+    ScipPythonNoOutput,
+    ScipPythonNotInstalled,
+    run_scip_python_index,
+)
+from hypergumbo_lang_scip_python.translate import translate_scip_python_to_hg
+
+__version__ = "8.1.0"
+
+#: Module paths for analyzer discovery via entry-points (ADR-0012 Step 1).
+ANALYZER_MODULES = [
+    "hypergumbo_lang_scip_python.analyzer",
+]
+
+__all__ = [
+    "ANALYZER_MODULES",
+    "ScipPythonError",
+    "ScipPythonInvocationFailed",
+    "ScipPythonNoOutput",
+    "ScipPythonNotInstalled",
+    "run_scip_python_index",
+    "should_use_scip_python_backend",
+    "translate_scip_python_to_hg",
+]

hypergumbo_lang_scip_python/analyzer.py

@@ -0,0 +1,141 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+"""Registered analyzer entry point for the scip-python backend (WI-nanom).
+
+Registered as ``scip_python``: a second BACKEND for the language ``python``,
+beside the ast-based ``python`` analyzer (ADR-0057 §10). The registry can
+see that the two are producers for one language and how their records
+pair: this arm's ``Symbol.name`` is the SCIP descriptor name as emitted
+(``area``, never ``Shape.area``) and its ``Symbol.span`` is the identifier
+TOKEN of the Definition occurrence, so the merge pass tests token-inside-item
+against the syntax arm's item span. No measured authority is declared —
+the first two-arm table (lab notebook 2026-09-19) showed the arms agree on
+``kind`` 4,721 times out of 4,723 — and ``executes_analysed_code`` is
+False: pyright infers, it does not run the analysed code, which is why the
+opt-in may live in a config file (ADR-0045 ruling 5).
+
+When the gate is False (the default) the analyzer returns a skipped result
+with ``backend_disabled``, so the orchestrator records an honest
+``skipped_passes`` entry. When the binary is missing, exits non-zero or
+writes no index, the corresponding pass-silence code travels with the skip
+(``dependency_unavailable`` / ``pass_crashed`` / ``unreported``) — the same
+discrimination WI-luvud gave the Rust arm. A completed run that produced
+nothing is NOT a skip: the pass ran, and says so.
+"""
+from __future__ import annotations
+
+import tempfile
+import warnings
+from pathlib import Path
+from typing import Callable, Optional
+
+from google.protobuf.message import DecodeError
+
+from hypergumbo_core.analyze.base import AnalysisResult
+from hypergumbo_core.analyze.registry import (
+    SPAN_ROLE_TOKEN,
+    MergeAnchor,
+    as_emitted,
+    register_analyzer,
+)
+from hypergumbo_core.ir import PASS_VERSION, AnalysisRun, Edge, Symbol
+from hypergumbo_core.pass_silence import (
+    BACKEND_DISABLED,
+    DEPENDENCY_UNAVAILABLE,
+    PASS_CRASHED,
+    UNREPORTED,
+    silence_reason_for_candidates,
+)
+
+from hypergumbo_lang_scip_python.gate import should_use_scip_python_backend
+from hypergumbo_lang_scip_python.invoke import (
+    ScipPythonError,
+    ScipPythonNoOutput,
+    ScipPythonNotInstalled,
+    run_scip_python_index,
+)
+from hypergumbo_lang_scip_python.translate import translate_scip_python_to_hg
+
+InvokeFn = Callable[..., bytes]
+TranslateFn = Callable[..., "tuple[list[Symbol], list[Edge]]"]
+
+
+def _silence_code_for(exc: Exception) -> str:
+    """Map an invocation failure onto the closed pass-silence axis (see the module docstring)."""
+    if isinstance(exc, ScipPythonNotInstalled):
+        return DEPENDENCY_UNAVAILABLE
+    if isinstance(exc, ScipPythonNoOutput):
+        return UNREPORTED
+    return PASS_CRASHED
+
+
+def _emit_user_warning(message: str) -> None:
+    warnings.warn(message, UserWarning, stacklevel=3)
+
+
+def _repo_has_py_files(repo_root: Path) -> bool:
+    try:
+        return next(iter(repo_root.rglob("*.py")), None) is not None
+    except OSError:  # pragma: no cover — pure defensive
+        return False
+
+
+def analyze_python_with_scip_impl(
+    repo_root: Path,
+    *,
+    invoke: Optional[InvokeFn] = None,
+    translate: Optional[TranslateFn] = None,
+    gate: Optional[Callable[..., bool]] = None,
+    log: Optional[Callable[[str], None]] = None,
+) -> AnalysisResult:
+    """The body of the registered analyzer, with every collaborator injectable."""
+    decide = gate if gate is not None else should_use_scip_python_backend
+    if not decide(repo_root=repo_root):
+        return AnalysisResult(
+            skipped=True,
+            skip_reason="scip-python backend not enabled",
+            skip_reason_code=BACKEND_DISABLED,
+        )
+    run = AnalysisRun.create(  # nosec B106 — a pass NAME, not a password
+        pass_id="scip_python", version=PASS_VERSION,
+    )
+    do_invoke = invoke if invoke is not None else run_scip_python_index
+    do_translate = translate if translate is not None else translate_scip_python_to_hg
+    emit = log if log is not None else _emit_user_warning
+    try:
+        with tempfile.TemporaryDirectory(prefix="hypergumbo-scip-python-") as scratch:
+            scip_bytes = do_invoke(repo_root, cwd=Path(scratch), project_name=repo_root.name or "project")
+        symbols, edges = do_translate(scip_bytes, run_id=run.execution_id)
+    except (ScipPythonError, DecodeError) as exc:
+        emit(f"scip-python backend did not run on {repo_root}: {exc}")
+        return AnalysisResult(
+            skipped=True,
+            skip_reason=f"scip-python backend: {exc}",
+            skip_reason_code=_silence_code_for(exc),
+        )
+    if not symbols and _repo_has_py_files(repo_root):
+        emit(
+            f"scip-python backend produced no symbols for {repo_root} despite .py "
+            f"files being present — likely a project scip-python could not index.",
+        )
+    run.silence_reason = silence_reason_for_candidates(symbols)
+    return AnalysisResult(run=run, symbols=symbols, edges=edges)
+
+
+@register_analyzer(
+    "scip_python",
+    priority=45,
+    languages=["python"],
+    backend="scip",
+    # INV-gabak: the shared SCIP translation stamps this synthetic pass id
+    # (ADR-0044, catalog._SYNTHETIC_PASS_IDS) on every record it emits, not
+    # this analyzer's registration name. Declared so a consumer joining
+    # Edge.origin back to the registry reads a statement, not a coincidence.
+    emits_origin="scip",
+    executes_analysed_code=False,
+    # As with the Rust SCIP arm: nothing to declare, because no tracked
+    # attribute's default is a concrete value any more (INV-kubup).
+    merge=MergeAnchor(name_key=as_emitted, span_role=SPAN_ROLE_TOKEN, observes=()),
+)
+def analyze_python_with_scip(repo_root: Path) -> AnalysisResult:
+    """Entry point for the SCIP-backed Python analyzer (see the module docstring)."""
+    return analyze_python_with_scip_impl(repo_root)

hypergumbo_lang_scip_python/gate.py

@@ -0,0 +1,56 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+"""Opt-in gate for the scip-python backend (WI-nanom).
+
+Two conditions, both required: the user asked, and the binary is there.
+
+"The user asked" is :func:`hypergumbo_core.backend_selection
+.resolve_scip_python_optin` — the ADR-0045 ruling 4 chain, flag >
+environment > CONFIG tiers. The config tiers are the tier the Rust backend
+cannot have: enabling rust-analyzer executes the analysed crate's
+``build.rs``, so its durable opt-in is a per-repository trust grant;
+pyright executes nothing, so ``[backends] scip_python = true`` in
+``config.toml`` or ``.hypergumbo.toml`` is an ordinary preference (ruling 5).
+The vocabulary and the ordering live in core, shared with the CLI, so the
+two cannot disagree about what ``--backend tree-sitter`` means.
+
+"The binary is there" is :func:`hypergumbo_core.scip_python_install
+.is_scip_python_available` — ``which`` plus a ``--version`` smoke test.
+Opted in but not installed returns False silently here; the CLI's
+``--backend scip-python`` path reports the missing binary at exit 2 before
+a run starts, and the analyzer records ``dependency_unavailable`` if the
+binary vanishes between the gate and the invocation.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Callable, Mapping, Optional
+
+from hypergumbo_core.backend_selection import (
+    SCIP_PYTHON_ENV_VAR,
+    resolve_scip_python_optin,
+)
+
+#: Re-exported so callers and tests import the variable name from here.
+ENV_VAR_NAME = SCIP_PYTHON_ENV_VAR
+
+
+def should_use_scip_python_backend(
+    *,
+    backend_flag: Optional[str] = None,
+    environ: Optional[Mapping[str, str]] = None,
+    is_available: Optional[Callable[[], bool]] = None,
+    repo_root: Optional[Path] = None,
+) -> bool:
+    """True iff the scip-python backend should run for ``repo_root``."""
+    env = environ if environ is not None else os.environ
+    decision = resolve_scip_python_optin(
+        flag_choice=backend_flag, environ=env, repo_root=repo_root,
+    )
+    if decision is not True:
+        return False
+    if is_available is None:
+        from hypergumbo_core.scip_python_install import is_scip_python_available
+
+        is_available = is_scip_python_available
+    return is_available()

hypergumbo_lang_scip_python/invoke.py

@@ -0,0 +1,103 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+"""Shell-out wrapper for ``scip-python index`` (WI-nanom).
+
+``scip-python index <project> --project-name NAME --output FILE`` writes a
+SCIP index for a Python project; pyright resolves the project's own
+modules and whatever is importable from the invoking interpreter's
+environment (so a project analysed inside its own virtualenv gets its
+dependencies typed too). It executes NOTHING from the project — static
+inference only — which is why this backend's opt-in is a preference and
+not a trust grant.
+
+:func:`run_scip_python_index` confirms the binary resolves, runs it with
+stdout/stderr captured and a timeout, and returns the index bytes. Failure
+modes map to three exceptions the analyzer turns into pass-silence codes:
+not installed (``dependency_unavailable``), non-zero exit or timeout
+(``pass_crashed``), and exit-0-with-no-index (``unreported``). ``which`` and
+``runner`` are injectable so tests never touch ``PATH`` or shell out.
+"""
+from __future__ import annotations
+
+import shutil
+import subprocess  # nosec B404 — required for the scip-python invocation
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+from hypergumbo_core.scip_python_install import SCIP_PYTHON_BINARY
+
+
+class ScipPythonError(Exception):
+    """Base class for :func:`run_scip_python_index` failures."""
+
+
+class ScipPythonNotInstalled(ScipPythonError):
+    """The ``scip-python`` binary is not resolvable."""
+
+
+class ScipPythonInvocationFailed(ScipPythonError):
+    """The binary ran but exited non-zero or timed out; carries stderr and the exit code."""
+
+    def __init__(self, message: str, stderr: bytes, *, returncode: Optional[int] = None) -> None:
+        super().__init__(message)
+        self.stderr = stderr
+        self.returncode = returncode
+
+
+class ScipPythonNoOutput(ScipPythonError):
+    """The invocation exited 0 but wrote no index."""
+
+    def __init__(self, message: str, stderr: bytes) -> None:
+        super().__init__(message)
+        self.stderr = stderr
+
+
+def run_scip_python_index(
+    project: Path,
+    *,
+    cwd: Path,
+    project_name: str = "hypergumbo-target",
+    scip_python_bin: str = SCIP_PYTHON_BINARY,
+    timeout_sec: float = 900.0,
+    which: Optional[Callable[[str], Optional[str]]] = None,
+    runner: Optional[Callable[..., Any]] = None,
+) -> bytes:
+    """Run ``scip-python index`` on ``project`` and return the SCIP bytes.
+
+    ``cwd`` is a caller-owned scratch directory that receives ``index.scip``;
+    the project itself is never written to. The timeout defaults to 15
+    minutes: scip-python indexed 179 files in 40 s at 2.1 GB RSS, and a
+    large monorepo should fail visibly rather than hang the pipeline.
+    """
+    resolve = which if which is not None else shutil.which
+    resolved = resolve(scip_python_bin)
+    if resolved is None:
+        raise ScipPythonNotInstalled(
+            f"'{scip_python_bin}' is not on PATH; install it with "
+            "npm install -g @sourcegraph/scip-python"
+        )
+    output = cwd / "index.scip"
+    argv = [
+        resolved, "index", str(project),
+        "--project-name", project_name,
+        "--output", str(output),
+    ]
+    run = runner if runner is not None else subprocess.run
+    try:
+        completed = run(  # nosec B603 — argv is built here from a resolved binary
+            argv, cwd=str(cwd), capture_output=True, timeout=timeout_sec, check=False,
+        )
+    except subprocess.TimeoutExpired as exc:
+        stderr = exc.stderr if isinstance(exc.stderr, bytes) else b""
+        raise ScipPythonInvocationFailed(
+            f"scip-python index timed out after {timeout_sec:.0f}s on {project}", stderr,
+        ) from exc
+    if completed.returncode != 0:
+        raise ScipPythonInvocationFailed(
+            f"scip-python index exited {completed.returncode} on {project}",
+            completed.stderr or b"", returncode=completed.returncode,
+        )
+    if not output.is_file():
+        raise ScipPythonNoOutput(
+            f"scip-python index exited 0 but wrote no {output}", completed.stderr or b"",
+        )
+    return output.read_bytes()

hypergumbo_lang_scip_python/translate.py

@@ -0,0 +1,133 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+"""SCIP → hypergumbo IR for scip-python output (WI-nanom).
+
+Three passes of the shared importer, plus two things scip-python's output
+needs that rust-analyzer's did not — measured on hypergumbo-core's own tree
+before this module was written (lab notebook 2026-09-19 12:15):
+
+1. **Drop what the syntax arm never models.** scip-python emits a global
+   symbol for every PARAMETER (``f().(x)`` — 4,634 on 179 files) and one
+   META ``__init__:`` declaration per module. The ``python`` analyzer emits
+   neither, so they could pair with nothing and would sit in the artifact
+   as thousands of one-sided records. The module is already the file node.
+
+2. **Keep the receiver's module on external callees.** The shared edge
+   builders drop a reference whose target is not an in-repo Symbol. That is
+   right for rust-analyzer, which resolved nothing outside the crate; it
+   throws away exactly what pyright is for. Of the syntax arm's 4,133
+   method-call stubs whose receiver module it could not determine,
+   scip-python resolved 3,973 (96.1%) — 3,840 of them to the stdlib. Those
+   become external ``calls`` edges here, on the id shape the syntax arm
+   mints when IT knows the module (``python:pathlib.Path:0-0:glob:unresolved``,
+   ``ExternalRef(module_path="pathlib.Path", name="glob")``, via
+   :func:`hypergumbo_core.ir.format_legacy_dst`), so the two arms are
+   comparable at every call site and a consumer keying on the module —
+   the I/O-boundary catalogue behind ``verify-claims`` — can read it.
+
+Only METHOD-descriptor externals (callables) are kept; an external
+``references`` edge (a type annotation naming ``Path``) is noise for a call
+graph and the syntax arm emits nothing to pair it with. ``call_construct``
+is stamped ``method`` when the descriptor has a class parent and
+``function`` otherwise, the same vocabulary the syntax arm uses.
+"""
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+from hypergumbo_core.ir import Edge, ExternalRef, Symbol, format_legacy_dst
+from hypergumbo_core.scip._generated import scip_pb2
+from hypergumbo_core.scip.calls import scip_index_to_call_edges
+from hypergumbo_core.scip.descriptor import DescriptorKind, parse_scip_symbol
+from hypergumbo_core.scip.edges import scip_index_to_edges
+from hypergumbo_core.scip.index import scip_index_to_symbols
+
+#: Symbol kinds the importer mints for descriptors the syntax arm never models.
+DROPPED_KINDS = frozenset({"parameter", "declaration"})
+
+#: The generated protobuf module carries no type information; read it as Any
+#: (the same accommodation the Rust translation makes).
+_generated: Any = scip_pb2
+
+
+def _external_ref(scip_symbol: str) -> Optional[Tuple[ExternalRef, str]]:
+    """``(ExternalRef, call_construct)`` for an external METHOD descriptor, else None.
+
+    ``scip-python python python-stdlib 3.11 pathlib/Path#glob().`` →
+    ``ExternalRef("python", "pathlib.Path", "glob")``, ``"method"``;
+    ``scip-python python python-stdlib 3.11 re/compile().`` →
+    ``ExternalRef("python", "re", "compile")``, ``"function"``.
+    """
+    try:
+        parsed = parse_scip_symbol(scip_symbol)
+    except ValueError:
+        return None
+    descriptors = parsed.descriptors
+    if not descriptors or descriptors[-1].kind is not DescriptorKind.METHOD:
+        return None
+    module_path = ".".join(d.name for d in descriptors[:-1])
+    if not module_path:
+        return None
+    has_class_parent = any(d.kind is DescriptorKind.TYPE for d in descriptors[:-1])
+    return (
+        ExternalRef(lang="python", module_path=module_path, name=descriptors[-1].name),
+        "method" if has_class_parent else "function",
+    )
+
+
+def translate_scip_python_to_hg(
+    scip_bytes: bytes, *, run_id: str,
+) -> Tuple[List[Symbol], List[Edge]]:
+    """Parse ``scip_bytes`` and return ``(symbols, edges)``.
+
+    ``run_id`` is the analyzer's own run: every Symbol and Edge names it, so
+    the artifact's provenance resolves to a serialized run (WI-didag).
+    """
+    index = _generated.Index()
+    index.ParseFromString(scip_bytes)
+    symbols = [s for s in scip_index_to_symbols(index) if s.kind not in DROPPED_KINDS]
+    for symbol in symbols:
+        symbol.origin_run_id = run_id
+
+    id_by_scip_symbol: Dict[str, str] = {
+        (sym.meta or {}).get("scip_symbol", ""): sym.id
+        for sym in symbols
+        if sym.meta and sym.meta.get("scip_symbol")
+    }
+    external: Dict[str, Tuple[ExternalRef, str]] = {}
+
+    def _resolve(scip_symbol: str) -> Optional[str]:
+        # In-repo: the defining Symbol's id. External callable: the syntax
+        # arm's module-qualified unresolved id, remembered so the edge can be
+        # given its structured dst_ref below. Anything else: skip the edge.
+        internal = id_by_scip_symbol.get(scip_symbol)
+        if internal is not None:
+            return internal
+        if scip_symbol in external:
+            return format_legacy_dst(external[scip_symbol][0])
+        ref = _external_ref(scip_symbol)
+        if ref is None:
+            return None
+        external[scip_symbol] = ref
+        return format_legacy_dst(ref[0])
+
+    edges: List[Edge] = []
+    edges.extend(scip_index_to_edges(index, run_id=run_id, resolve_symbol=_resolve))
+    edges.extend(scip_index_to_call_edges(index, run_id=run_id, resolve_symbol=_resolve))
+    by_dst = {format_legacy_dst(ref): (ref, construct) for ref, construct in external.values()}
+    kept: List[Edge] = []
+    for edge in edges:
+        hit = by_dst.get(edge.dst)
+        if hit is None:
+            kept.append(edge)
+            continue
+        if edge.edge_type != "calls":
+            continue  # an external non-call reference: nothing to pair, nothing to type
+        ref, construct = hit
+        edge.dst_ref = ref
+        edge.is_resolved = False
+        edge.meta = {**(edge.meta or {}), "call_construct": construct}
+        kept.append(edge)
+    return symbols, kept
+
+
+SourceReader = Callable[[str], Optional[bytes]]

hypergumbo_lang_scip_python-8.1.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.5
+Name: hypergumbo-lang-scip-python
+Version: 8.1.0
+Summary: SCIP-backed Python analyzer for hypergumbo (scip-python / pyright integration)
+Author: Hypergumbo contributors
+License: AGPL-3.0-or-later
+Keywords: code-graph,pyright,python,scip,static-analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Requires-Dist: hypergumbo-core==8.1.0
+Requires-Dist: hypergumbo-lang-mainstream==8.1.0
+Description-Content-Type: text/markdown
+
+<!-- SPDX-License-Identifier: AGPL-3.0-or-later -->
+# hypergumbo-lang-scip-python
+
+SCIP-backed Python analyzer for hypergumbo, driven by
+[scip-python](https://github.com/sourcegraph/scip-python) (pyright).
+
+This optional package is the second opt-in fidelity backend (after
+`hypergumbo-lang-rust-analyzer`) and the first that **executes nothing** from
+the analysed repository: pyright performs static inference only. It runs
+*beside* the ast-based `python` analyzer, never instead of it — the two
+producers' records for one declaration are folded into one node by the
+ADR-0057 merge pass, and every disagreement stays visible in the provenance
+slot.
+
+## What it adds, measured
+
+On hypergumbo-core's own 179 source files (2026-09-19, scip-python 0.6.6):
+the syntax arm left 4,133 method-call receivers untyped (`obj.method()` with
+`obj` of unknown module); scip-python typed **3,973 of them (96.1%)** — 3,840
+to the stdlib (`builtins.str`, `dict`, `list`, `pathlib.Path`, `re.Pattern`, …),
+96 in-repo, 37 third-party. That module is what `hypergumbo verify-claims`'s
+I/O-boundary and taint verdicts key on. The Rust backend measured zero
+receivers typed.
+
+## Enabling it
+
+```
+npm install -g @sourcegraph/scip-python@0.6.6     # the producer (node + npm)
+pipx install 'hypergumbo[scip-python]'            # this wrapper
+hypergumbo survey . --backend scip-python         # one run
+```
+
+Durably, as a preference in either ADR-0045 config tier (allowed because the
+backend executes nothing):
+
+```toml
+# $XDG_CONFIG_HOME/hypergumbo/config.toml  or  <repo>/.hypergumbo.toml
+[backends]
+scip_python = true
+```
+
+`HYPERGUMBO_SCIP_PYTHON=1` is the environment spelling; `--backend tree-sitter`
+turns every opt-in backend off for one run. Precedence: flag > environment >
+project config > user config.
+
+When enabled but the binary or this package is missing, the CLI exits 2 with
+the install line rather than silently falling through.
+
+## What the translation does with scip-python's output
+
+- Global definitions become `Symbol`s through the shared importer
+  (`hypergumbo_core.scip`); scip-python declares no `Document.language` and
+  no `SymbolInformation.kind`, so the importer reads the file extension and
+  the SCIP descriptor grammar instead.
+- Parameter symbols and the per-module `__init__:` declaration are dropped:
+  the syntax arm models neither, and a node nothing can pair with is noise.
+- References to in-repo definitions become `calls` / `references` edges.
+- References to **external** callables (stdlib, third-party) become external
+  call edges carrying the receiver's module — `python:pathlib.Path:0-0:glob:unresolved`
+  with a structured `dst_ref` — the same shape the syntax arm mints when it
+  knows the module, so the two arms are comparable at every call site.
+
+## Recorded fixture
+
+`recorded/sample_project/` is a three-file package and the `index.scip`
+scip-python 0.6.6 emitted for it (`metadata.project_root` normalised). Every
+cross-backend test reads that recording, never anything derived from the
+syntax arm's own output (ADR-0057 §12).

hypergumbo_lang_scip_python-8.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+hypergumbo_lang_scip_python/__init__.py,sha256=VaRhpUF0uzQpMlS5OFe0hmBRMBDyRc3X_ebMTt25aeU,1576
+hypergumbo_lang_scip_python/analyzer.py,sha256=LYFy7KDXV4hJw7wAKEKLhUlQ9JhoXzvZDiolxC9iwi8,5880
+hypergumbo_lang_scip_python/gate.py,sha256=8pA-JjXC4FXZEgKvof5qCbCKbPUZVJG0UzMRToljTNs,2261
+hypergumbo_lang_scip_python/invoke.py,sha256=Ea1rARro7FxGJBCTkFGi_WAEPJXKU06rhE7sJFw0b9E,4123
+hypergumbo_lang_scip_python/translate.py,sha256=uazccEipaUm85wGNS8QmYzmrE4BGASO3vwDMPJ0d2xE,6027
+hypergumbo_lang_scip_python-8.1.0.dist-info/METADATA,sha256=q3cWXOjflZCseV6Z7zDK8EWTNMl_-UvDLWeqTLNB_QY,3738
+hypergumbo_lang_scip_python-8.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+hypergumbo_lang_scip_python-8.1.0.dist-info/entry_points.txt,sha256=65bmWVDWBvapMOw-mdY8veEYv0HkhoHZ0ILEJ5lwRb0,82
+hypergumbo_lang_scip_python-8.1.0.dist-info/RECORD,,

hypergumbo_lang_scip_python-8.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

hypergumbo_lang_scip_python-8.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[hypergumbo.analyzers]
+scip_python = hypergumbo_lang_scip_python:ANALYZER_MODULES