lean-runtime 2.0.5__tar.gz → 2.0.6__tar.gz

{lean_runtime-2.0.5 → lean_runtime-2.0.6}/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+## 2.0.6
+
+- Preserve the highest-ranked Lean compiler rejection when automatic discovery
+  exhausts its candidates, including raw output and parsed diagnostics in both
+  human and JSON `lean-run` output.
+- Add line-oriented and NDJSON request/response helpers to `InteractiveSession`
+  for incremental REPLs and ready-to-run checker programs.
+
 ## 2.0.5
 
 - Integrate bounded exact-environment discovery into the `lean-runtime` package.

{lean_runtime-2.0.5/lean_runtime.egg-info → lean_runtime-2.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-runtime
-Version: 2.0.5
+Version: 2.0.6
 Summary: Run Lean 4 proofs from Python or standalone files
 Author: Alejandro Radisic
 License-Expression: Apache-2.0

{lean_runtime-2.0.5 → lean_runtime-2.0.6}/docs/python-api.md

@@ -179,9 +179,7 @@ with environment.spawn_interactive(
     policy=ExecutionPolicy(timeout_seconds=3600, memory_mb=4096),
 ) as session:
     request = {"id": 1, "method": "get_info", "params": {}}
-    session.stdin.write(json.dumps(request) + "\n")
-    session.stdin.flush()
-    response = json.loads(session.stdout.readline())
+    response = session.request_json(request)
     assert session.running
 
 result = session.close()
@@ -199,6 +197,12 @@ the original text is still returned to the caller. Callers of tools that emit
 substantial data on both streams should drain both streams to avoid ordinary
 subprocess pipe backpressure.
 
+For line-oriented tools, `send_line()` and `read_line()` provide incremental
+REPL-style access. `request_line()` serializes one request/response exchange,
+and `request_json()` does the same for NDJSON protocols. The request helpers
+are locked so concurrent callers cannot interleave protocol frames. The raw
+`stdin`, `stdout`, and `stderr` pipes remain available for other protocols.
+
 ## Progress events
 
 ```python

{lean_runtime-2.0.5 → lean_runtime-2.0.6}/docs/ready-programs.md

@@ -20,11 +20,14 @@ program = runtime.create_program(
 )
 
 with program.spawn_interactive() as session:
-    session.stdin.write("hello\n")
-    session.stdin.flush()
-    print(session.stdout.readline())
+    print(session.request_line("hello"))
 ```
 
+For an NDJSON checker, `session.request_json({...})` keeps the compiled process
+alive and returns one decoded response per request. This is the fast path for
+large batches: prepare and verify the checker once, then stream compact inputs
+instead of elaborating a new Lean source file for every item.
+
 `create_program` records the program's files and computer compatibility. Opening
 it later with `runtime.program(program.id)` verifies that neither has changed.
 

{lean_runtime-2.0.5 → lean_runtime-2.0.6}/lean_runtime/discovery/engine.py

@@ -336,11 +336,17 @@ def discover(
             DISCOVERY_EXHAUSTED,
             f"Lean did not accept the source in any of {len(attempts)} tested candidates",
         )
+    rejection_diagnostics = tuple(
+        diagnostic
+        for attempt in attempts
+        if attempt.status == "lean_rejected"
+        for diagnostic in attempt.diagnostics
+    )
     return DiscoveryResult(
         status="not_found",
         confidence="exhausted",
         plan=plan,
         attempts=tuple(attempts),
         duration_seconds=time.monotonic() - started,
-        diagnostics=(reason,),
+        diagnostics=(reason, *rejection_diagnostics),
     )

{lean_runtime-2.0.5 → lean_runtime-2.0.6}/lean_runtime/discovery/result.py

@@ -124,9 +124,22 @@ class DiscoveryResult:
         compiled = next((item for item in self.attempts if item.status == "compiled"), None)
         return compiled.environment_id if compiled is not None else None
 
+    @property
+    def rejection_attempt(self) -> CandidateAttempt | None:
+        """Return the highest-ranked attempt for which Lean rejected the source."""
+        return next(
+            (
+                attempt
+                for attempt in self.attempts
+                if attempt.status == "lean_rejected" and attempt.execution_result is not None
+            ),
+            None,
+        )
+
     def raise_for_error(self) -> DiscoveryResult:
         if self.status != "found":
-            detail = self.diagnostics[0].detail if self.diagnostics else self.status
+            details = [item.detail for item in self.diagnostics]
+            detail = ": ".join(dict.fromkeys(details)) if details else self.status
             raise DiscoveryError(f"Lean environment discovery did not succeed: {detail}")
         return self
 

{lean_runtime-2.0.5 → lean_runtime-2.0.6}/lean_runtime/environments.py

@@ -17,7 +17,7 @@ from contextlib import suppress
 from dataclasses import asdict, dataclass
 from datetime import datetime, timezone
 from pathlib import Path, PurePosixPath
-from typing import Any, Generic, TextIO, TypeVar, cast
+from typing import Any, Generic, Literal, TextIO, TypeVar, cast
 
 from ._git import git_command
 from ._paths import remove_tree
@@ -291,6 +291,7 @@ class InteractiveSession:
         self._cleanup = cleanup
         self._result: ExecutionResult | None = None
         self._closing = threading.Lock()
+        self._io = threading.RLock()
 
     @property
     def stdin(self) -> TextIO:
@@ -316,6 +317,63 @@ class InteractiveSession:
         """Return the process exit code, or ``None`` while it is running."""
         return self._process.poll()
 
+    def _reader(self, stream: Literal["stdout", "stderr"]) -> InteractiveTextReader:
+        if stream == "stdout":
+            return self.stdout
+        if stream == "stderr":
+            return self.stderr
+        raise ValueError("stream must be 'stdout' or 'stderr'")
+
+    def send_line(self, line: str) -> None:
+        """Send and flush one line-oriented protocol request."""
+        if not isinstance(line, str):
+            raise TypeError("interactive request must be a string")
+        if "\n" in line or "\r" in line:
+            raise ValueError("interactive request must contain exactly one line")
+        with self._io:
+            if not self.running:
+                raise EnvironmentError("interactive process is not running")
+            try:
+                self.stdin.write(line + "\n")
+                self.stdin.flush()
+            except (BrokenPipeError, OSError, ValueError) as exc:
+                raise EnvironmentError("interactive process did not accept the request") from exc
+
+    def read_line(self, *, stream: Literal["stdout", "stderr"] = "stdout") -> str:
+        """Read one response line from stdout or stderr."""
+        with self._io:
+            response = self._reader(stream).readline()
+            if response == "":
+                raise EnvironmentError(
+                    f"interactive process ended before producing a {stream} response"
+                )
+            return response.removesuffix("\n").removesuffix("\r")
+
+    def request_line(
+        self,
+        line: str,
+        *,
+        response_stream: Literal["stdout", "stderr"] = "stdout",
+    ) -> str:
+        """Atomically send one line and read its corresponding response."""
+        with self._io:
+            self.send_line(line)
+            return self.read_line(stream=response_stream)
+
+    def request_json(
+        self,
+        value: object,
+        *,
+        response_stream: Literal["stdout", "stderr"] = "stdout",
+    ) -> Any:
+        """Round-trip one newline-delimited JSON value through the live process."""
+        request = json.dumps(value, ensure_ascii=False, separators=(",", ":"))
+        response = self.request_line(request, response_stream=response_stream)
+        try:
+            return json.loads(response)
+        except json.JSONDecodeError as exc:
+            raise EnvironmentError("interactive process returned invalid JSON") from exc
+
     def close(self) -> ExecutionResult:
         """Send EOF, stop if necessary, persist provenance, and remove the instance."""
         with self._closing:

{lean_runtime-2.0.5 → lean_runtime-2.0.6}/lean_runtime/run_cli.py

@@ -314,14 +314,18 @@ def main(argv: list[str] | None = None) -> int:
                     runtime_events=runtime_events,
                 ).discover_and_check(source)
                 if discovered.status != "found" or discovered.execution_result is None:
-                    raise SpecificationError(_discovery_failure(discovered)) from None
-                if arguments.lock_out is not None:
-                    assert discovered.lock is not None
-                    discovered.lock.write(arguments.lock_out)
+                    rejection = discovered.rejection_attempt
+                    if rejection is None or rejection.execution_result is None:
+                        raise SpecificationError(_discovery_failure(discovered)) from None
+                    result = rejection.execution_result
+                else:
+                    if arguments.lock_out is not None:
+                        assert discovered.lock is not None
+                        discovered.lock.write(arguments.lock_out)
+                    result = discovered.execution_result
                 preparation = PhaseTiming(
                     "discovery", round((time.monotonic() - discovery_started) * 1000)
                 )
-                result = discovered.execution_result
         if context.lock is not None or context.toolchain is not None or not context.requires:
             result = replace(result, timings=(preparation, *result.timings))
         _emit(

{lean_runtime-2.0.5 → lean_runtime-2.0.6/lean_runtime.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-runtime
-Version: 2.0.5
+Version: 2.0.6
 Summary: Run Lean 4 proofs from Python or standalone files
 Author: Alejandro Radisic
 License-Expression: Apache-2.0

{lean_runtime-2.0.5 → lean_runtime-2.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lean-runtime"
-version = "2.0.5"
+version = "2.0.6"
 description = "Run Lean 4 proofs from Python or standalone files"
 readme = "README.md"
 requires-python = ">=3.10"

{lean_runtime-2.0.5 → lean_runtime-2.0.6}/schemas/execution-v1.schema.json

@@ -29,7 +29,7 @@
       "required": ["phase", "duration_ms", "performed"],
       "additionalProperties": false,
       "properties": {
-        "phase": {"enum": ["toolchain", "resolution", "source_acquisition", "cache_lookup", "cache_download", "artifact_hydration", "build", "publication", "environment_open", "instance_creation", "input_staging", "execution", "result_collection", "result_publication", "cleanup"]},
+        "phase": {"enum": ["discovery", "toolchain", "resolution", "source_acquisition", "cache_lookup", "cache_download", "artifact_hydration", "build", "publication", "environment_open", "instance_creation", "input_staging", "execution", "result_collection", "result_publication", "cleanup"]},
         "duration_ms": {"type": "integer", "minimum": 0},
         "performed": {"type": "boolean"}
       }

{lean_runtime-2.0.5 → lean_runtime-2.0.6}/tests/discovery/test_engine.py

@@ -7,7 +7,13 @@ from dataclasses import dataclass, field
 import pytest
 
 from lean_runtime import ExecutionResult, Runtime
-from lean_runtime.discovery import Discovery, DiscoveryPolicy, PolicyError, ProbeOutcome
+from lean_runtime.discovery import (
+    Discovery,
+    DiscoveryError,
+    DiscoveryPolicy,
+    PolicyError,
+    ProbeOutcome,
+)
 from lean_runtime.discovery.candidate import Candidate
 from lean_runtime.discovery.probe import ProbeIntegrityFailure, ProbeUnavailable
 
@@ -87,6 +93,25 @@ def test_candidate_budget_never_opens_bounded_candidate(sample_catalog) -> None:
     assert probe.opened == ["mathlib-new"]
 
 
+def test_exhaustion_surfaces_the_highest_ranked_lean_rejection(sample_catalog) -> None:  # type: ignore[no-untyped-def]
+    probe = FakeProbe({"mathlib-new": execution(False, stderr="type mismatch")})
+    result = Discovery(
+        catalog=sample_catalog,
+        policy=DiscoveryPolicy(max_candidates=1),
+        probe=probe,
+    ).discover_and_check("import Mathlib\n")
+
+    assert result.status == "not_found"
+    assert result.rejection_attempt is result.attempts[0]
+    assert [item.code for item in result.diagnostics] == [
+        "DISCOVERY_CANDIDATE_LIMIT",
+        "CANDIDATE_LEAN_REJECTED",
+    ]
+    assert result.diagnostics[1].detail == "type mismatch"
+    with pytest.raises(DiscoveryError, match="type mismatch"):
+        result.raise_for_error()
+
+
 def test_unavailable_candidate_advances(sample_catalog) -> None:  # type: ignore[no-untyped-def]
     probe = FakeProbe(
         {

{lean_runtime-2.0.5 → lean_runtime-2.0.6}/tests/test_interactive.py

@@ -8,7 +8,7 @@ from pathlib import Path
 
 import pytest
 
-from lean_runtime import EnvironmentLock, ExecutionPolicy
+from lean_runtime import EnvironmentError, EnvironmentLock, ExecutionPolicy
 from lean_runtime.backends import LocalBackend
 from lean_runtime.environments import Environment, EnvironmentManager
 from lean_runtime.store import EnvironmentStore
@@ -79,9 +79,7 @@ def test_interactive_session_round_trips_and_records_transcript(tmp_path: Path)
         execution_id = session.execution_id
         assert session.running
         assert session.poll() is None
-        session.stdin.write("hello lean\n")
-        session.stdin.flush()
-        assert session.stdout.readline() == "HELLO LEAN\n"
+        assert session.request_line("hello lean") == "HELLO LEAN"
         assert any(environment.manager.store.jobs.iterdir())
 
     result = session.close()
@@ -97,6 +95,23 @@ def test_interactive_session_round_trips_and_records_transcript(tmp_path: Path)
     assert record["operation"] == "interactive"
 
 
+def test_interactive_session_round_trips_ndjson(tmp_path: Path) -> None:
+    environment = _environment(tmp_path)
+    script = (
+        "import json, sys\n"
+        "for line in sys.stdin:\n"
+        " value = json.loads(line)\n"
+        " print(json.dumps({'id': value['id'], 'answer': value['value'] + 1}), flush=True)"
+    )
+    with environment.spawn_interactive([sys.executable, "-u", "-c", script]) as session:
+        assert session.request_json({"id": 7, "value": 41}) == {"id": 7, "answer": 42}
+        with pytest.raises(ValueError, match="exactly one line"):
+            session.send_line("first\nsecond")
+
+    with pytest.raises(EnvironmentError, match="not running"):
+        session.send_line("late request")
+
+
 def test_interactive_timeout_is_enforced_and_instance_is_removed(tmp_path: Path) -> None:
     environment = _environment(tmp_path)
     session = environment.spawn_interactive(

{lean_runtime-2.0.5 → lean_runtime-2.0.6}/tests/test_programs.py

@@ -34,9 +34,7 @@ def test_program_identity_payload_validation_and_interactive_execution(tmp_path:
 
     assert program.id.startswith("program_")
     with program.spawn_interactive(policy=ExecutionPolicy(timeout_seconds=10)) as session:
-        session.stdin.write('{"ping":true}\n')
-        session.stdin.flush()
-        assert session.stdout.readline() == '{"ping":true}\n'
+        assert session.request_json({"ping": True}) == {"ping": True}
     assert session.close().provenance is not None
     assert session.close().provenance.program_id == program.id
 

{lean_runtime-2.0.5 → lean_runtime-2.0.6}/tests/test_run_cli.py

@@ -1,20 +1,27 @@
+import json
 from pathlib import Path
 
 from lean_runtime import ProjectError
-from lean_runtime.models import ExecutionResult
+from lean_runtime.models import Diagnostic, ExecutionResult
 from lean_runtime.run_cli import main
 
 
-def _result() -> ExecutionResult:
+def _result(
+    *,
+    ok: bool = True,
+    stderr: str = "",
+    diagnostics: tuple[Diagnostic, ...] = (),
+) -> ExecutionResult:
     return ExecutionResult(
-        ok=True,
-        exit_code=0,
+        ok=ok,
+        exit_code=0 if ok else 1,
         toolchain="leanprover/lean4:v4.32.0",
         command=("lean", "Main.lean"),
         cwd="/tmp",
         stdout="",
-        stderr="",
+        stderr=stderr,
         elapsed_seconds=0.01,
+        diagnostics=diagnostics,
     )
 
 
@@ -158,6 +165,65 @@ def test_lean_run_discovers_standalone_file_and_writes_lock(
     assert "accepted" in capsys.readouterr().out
 
 
+def test_lean_run_preserves_discovered_compiler_rejection(
+    monkeypatch, tmp_path: Path, capsys
+) -> None:
+    source = tmp_path / "Main.lean"
+    source.write_text("import Mathlib\nexample : False := by trivial\n")
+    rejection = _result(
+        ok=False,
+        stderr="Main.lean:2:22: error: tactic 'trivial' failed",
+        diagnostics=(
+            Diagnostic(
+                "error",
+                "tactic 'trivial' failed",
+                file="Main.lean",
+                line=2,
+                column=22,
+            ),
+        ),
+    )
+
+    class NoProjectRuntime(FakeRuntime):
+        def __init__(self, **kwargs) -> None:
+            super().__init__(**kwargs)
+            self.availability = "auto"
+            self.libraries = ()
+
+        def check_file(self, *_args, **_kwargs) -> ExecutionResult:
+            raise ProjectError("no project")
+
+    class Attempt:
+        execution_result = rejection
+
+    class Rejected:
+        status = "not_found"
+        execution_result = None
+        rejection_attempt = Attempt()
+
+    class FakeDiscovery:
+        def __init__(self, **_kwargs) -> None:
+            pass
+
+        def discover_and_check(self, _source: str) -> Rejected:
+            return Rejected()
+
+    monkeypatch.setattr("lean_runtime.run_cli.Runtime", NoProjectRuntime)
+    monkeypatch.setattr("lean_runtime.run_cli.Discovery", FakeDiscovery)
+
+    assert main([str(source), "--quiet"]) == 1
+    captured = capsys.readouterr()
+    assert "tactic 'trivial' failed" in captured.err
+    assert "rejected" in captured.out
+
+    assert main([str(source), "--json", "--quiet"]) == 1
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["ok"] is False
+    assert payload["data"]["stderr"].endswith("tactic 'trivial' failed")
+    assert payload["data"]["diagnostics"][0]["message"] == "tactic 'trivial' failed"
+    assert payload["data"]["timings"][0]["phase"] == "discovery"
+
+
 def test_lean_run_can_disable_automatic_discovery(monkeypatch, tmp_path: Path, capsys) -> None:
     source = tmp_path / "Main.lean"
     source.write_text("import Mathlib\n")

{lean_runtime-2.0.5 → lean_runtime-2.0.6}/tests/test_schemas.py

@@ -58,7 +58,7 @@ def test_execution_success_fixture_matches_v1_schema() -> None:
         stdout="",
         stderr="",
         elapsed_seconds=0.01,
-        timings=(PhaseTiming("execution", 10),),
+        timings=(PhaseTiming("discovery", 5), PhaseTiming("execution", 10)),
     )
     _validator("execution-v1.schema.json").validate(serialize_execution_v1(result))