hypergumbo-lang-scip-python 9.1.0__tar.gz → 9.2.0__tar.gz

{hypergumbo_lang_scip_python-9.1.0 → hypergumbo_lang_scip_python-9.2.0}/.gitignore

@@ -15,6 +15,7 @@ build/
 
 # hypergumbo
 .hypergumbo/
+.hypergumbo-examples/
 hypergumbo_capsule/
 hypergumbo.results.json
 hypergumbo.results.*.json

{hypergumbo_lang_scip_python-9.1.0 → hypergumbo_lang_scip_python-9.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypergumbo-lang-scip-python
-Version: 9.1.0
+Version: 9.2.0
 Summary: SCIP-backed Python analyzer for hypergumbo (scip-python / pyright integration)
 Author: Hypergumbo contributors
 License: AGPL-3.0-or-later
@@ -10,8 +10,8 @@ Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or l
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.10
-Requires-Dist: hypergumbo-core==9.1.0
-Requires-Dist: hypergumbo-lang-mainstream==9.1.0
+Requires-Dist: hypergumbo-core==9.2.0
+Requires-Dist: hypergumbo-lang-mainstream==9.2.0
 Description-Content-Type: text/markdown
 
 <!-- SPDX-License-Identifier: AGPL-3.0-or-later -->

{hypergumbo_lang_scip_python-9.1.0 → hypergumbo_lang_scip_python-9.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypergumbo-lang-scip-python"
-version = "9.1.0"
+version = "9.2.0"
 description = "SCIP-backed Python analyzer for hypergumbo (scip-python / pyright integration)"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -18,8 +18,8 @@ classifiers = [
   "Programming Language :: Python :: 3 :: Only",
 ]
 dependencies = [
-  "hypergumbo-core==9.1.0",
-  "hypergumbo-lang-mainstream==9.1.0",
+  "hypergumbo-core==9.2.0",
+  "hypergumbo-lang-mainstream==9.2.0",
 ]
 
 [project.entry-points."hypergumbo.analyzers"]

{hypergumbo_lang_scip_python-9.1.0 → hypergumbo_lang_scip_python-9.2.0}/src/hypergumbo_lang_scip_python/__init__.py

@@ -6,7 +6,8 @@ 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
+  shared importer, plus two things the Rust arm never needed: it drops the
+  PARAMETER and META symbols the syntax arm never models, and 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.
@@ -23,7 +24,7 @@ from hypergumbo_lang_scip_python.invoke import (
 )
 from hypergumbo_lang_scip_python.translate import translate_scip_python_to_hg
 
-__version__ = "9.1.0"
+__version__ = "9.2.0"
 
 #: Module paths for analyzer discovery via entry-points (ADR-0012 Step 1).
 ANALYZER_MODULES = [

{hypergumbo_lang_scip_python-9.1.0 → hypergumbo_lang_scip_python-9.2.0}/src/hypergumbo_lang_scip_python/analyzer.py

@@ -19,7 +19,11 @@ with ``backend_disabled``, so the orchestrator records an honest
 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.
+nothing is NOT a skip: the pass ran, and says so -- as ``unreported`` when
+the tree holds Python, since an empty index of a Python project says the
+indexer saw no files, not that the files held nothing (WI-nijod: every run
+indexed an empty scratch directory, and ``no_candidate_construct``, a
+routine silence, hid it).
 """
 from __future__ import annotations
 
@@ -117,7 +121,9 @@ def analyze_python_with_scip_impl(
             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)
+        run.silence_reason = UNREPORTED
+    else:
+        run.silence_reason = silence_reason_for_candidates(symbols)
     return AnalysisResult(run=run, symbols=symbols, edges=edges)
 
 

{hypergumbo_lang_scip_python-9.1.0 → hypergumbo_lang_scip_python-9.2.0}/src/hypergumbo_lang_scip_python/invoke.py

@@ -1,14 +1,24 @@
 # 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
+``scip-python index --cwd <project> --project-name NAME --project-version 0
+--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.
 
+The project goes in ``--cwd``. scip-python 0.6.6 takes no positional
+project: handed one, it ignores it, indexes its own working directory and
+exits 0 -- and the subprocess runs in a scratch directory, so until WI-nijod
+every run indexed that empty directory ("Total Project Files 0") and
+returned a valid, empty index. The version is a constant: left out, it is
+the project's git revision, and outside a git checkout the indexer crashes
+on the first module (``normalizeNameOrVersion``). Nothing downstream reads
+it -- translation keys on the descriptors -- and a constant keeps symbol
+strings identical from one commit to the next.
+
 :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:
@@ -26,6 +36,14 @@ from typing import Any, Callable, Optional
 from hypergumbo_core.scip_python_install import SCIP_PYTHON_BINARY
 
 
+#: V8's fatal-error text when the heap limit is reached. The default limit
+#: (~4 GB) is too small for a large project: hypergumbo's own tree (1,712
+#: files) aborted at 4.2 GB RSS and indexed in 306 s at 8.4 GB with
+#: ``--max-old-space-size=9000`` (WI-nijod). The limit is the user's to set --
+#: it is memory on their machine -- so the failure names the knob instead.
+_NODE_HEAP_EXHAUSTED = b"JavaScript heap out of memory"
+
+
 class ScipPythonError(Exception):
     """Base class for :func:`run_scip_python_index` failures."""
 
@@ -77,8 +95,9 @@ def run_scip_python_index(
         )
     output = cwd / "index.scip"
     argv = [
-        resolved, "index", str(project),
+        resolved, "index", "--cwd", str(project),
         "--project-name", project_name,
+        "--project-version", "0",
         "--output", str(output),
     ]
     run = runner if runner is not None else subprocess.run
@@ -92,9 +111,14 @@ def run_scip_python_index(
             f"scip-python index timed out after {timeout_sec:.0f}s on {project}", stderr,
         ) from exc
     if completed.returncode != 0:
+        stderr = completed.stderr or b""
+        hint = (
+            "; node ran out of heap -- raise it with NODE_OPTIONS=--max-old-space-size=<MB>"
+            if _NODE_HEAP_EXHAUSTED in stderr else ""
+        )
         raise ScipPythonInvocationFailed(
-            f"scip-python index exited {completed.returncode} on {project}",
-            completed.stderr or b"", returncode=completed.returncode,
+            f"scip-python index exited {completed.returncode} on {project}{hint}",
+            stderr, returncode=completed.returncode,
         )
     if not output.is_file():
         raise ScipPythonNoOutput(

{hypergumbo_lang_scip_python-9.1.0 → hypergumbo_lang_scip_python-9.2.0}/tests/test_scip_python_analyzer.py

@@ -100,7 +100,11 @@ class TestSuccess:
         )
         assert result.skipped is False and result.run is not None and result.symbols == []
         assert logged and "produced no symbols" in logged[0]
-        assert result.run.silence_reason  # the pass ran and says what it saw
+        # Not ``no_candidate_construct``: that says the files were read and held
+        # nothing, and it is routine, so the [passes] line never names it. An
+        # index with no symbols for a tree with Python in it is CANNOT-DETERMINE
+        # (WI-nijod: every run indexed an empty scratch dir and looked clean).
+        assert result.run.silence_reason == UNREPORTED
 
     def test_the_default_warning_channel_is_a_user_warning(self, tmp_path: Path) -> None:
         with pytest.warns(UserWarning, match="did not run"):

{hypergumbo_lang_scip_python-9.1.0 → hypergumbo_lang_scip_python-9.2.0}/tests/test_scip_python_invoke.py

@@ -45,7 +45,13 @@ def test_a_successful_run_returns_the_index_bytes_and_the_argv_is_pinned(tmp_pat
     project.mkdir()
     out = run_scip_python_index(project, cwd=tmp_path, project_name="proj", which=_found, runner=runner)
     assert out == b"\x00scip"
-    assert seen["argv"] == ["/fake/bin/scip-python", "index", str(project), "--project-name", "proj",
+    # The project travels as ``--cwd``: scip-python 0.6.6 takes no positional
+    # project and silently indexes its own working directory -- the scratch dir,
+    # which is empty -- when handed one. And the version is given: left out,
+    # it is read from git, and outside a git checkout the indexer crashes on
+    # the first module (WI-nijod).
+    assert seen["argv"] == ["/fake/bin/scip-python", "index", "--cwd", str(project),
+                            "--project-name", "proj", "--project-version", "0",
                             "--output", str(tmp_path / "index.scip")]
     assert seen["kwargs"]["cwd"] == str(tmp_path) and seen["kwargs"]["timeout"] == 900.0
 
@@ -69,3 +75,19 @@ def test_a_timeout_is_an_invocation_failure(tmp_path: Path) -> None:
 def test_exit_zero_without_an_index_is_no_output(tmp_path: Path) -> None:
     with pytest.raises(ScipPythonNoOutput, match="wrote no"):
         run_scip_python_index(tmp_path, cwd=tmp_path, which=_found, runner=lambda argv, **kw: _Completed())
+
+
+def test_a_node_heap_exhaustion_names_the_remedy(tmp_path: Path) -> None:
+    """V8's default heap (~4 GB) is too small for a large project: indexing
+    hypergumbo itself (1,712 files) aborted at 4.2 GB RSS and finished with an
+    8 GB heap (WI-nijod). The crash is an exit code 134 and a V8 trace; the
+    message says what to set."""
+    oom = b"FATAL ERROR: Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap out of memory"
+    with pytest.raises(ScipPythonInvocationFailed, match="NODE_OPTIONS=--max-old-space-size") as excinfo:
+        run_scip_python_index(tmp_path, cwd=tmp_path, which=_found,
+                              runner=lambda argv, **kw: _Completed(returncode=134, stderr=oom))
+    assert excinfo.value.returncode == 134 and excinfo.value.stderr == oom
+    with pytest.raises(ScipPythonInvocationFailed) as other:
+        run_scip_python_index(tmp_path, cwd=tmp_path, which=_found,
+                              runner=lambda argv, **kw: _Completed(returncode=1, stderr=b"boom"))
+    assert "NODE_OPTIONS" not in str(other.value)