athanor-sdk 0.3.2__tar.gz

athanor_sdk-0.3.2/.github/dependabot.yml

@@ -0,0 +1,23 @@
+version: 2
+updates:
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    open-pull-requests-limit: 5
+    labels:
+      - "dependencies"
+      - "security"
+    commit-message:
+      prefix: "deps"
+      include: "scope"
+    # We ship to PyPI so transitive deps land on customers. Be paranoid:
+    # group patch-level updates so the maintenance noise stays manageable
+    # but security-critical updates surface immediately.
+    groups:
+      patch-updates:
+        patterns:
+          - "*"
+        update-types:
+          - "patch"

athanor_sdk-0.3.2/.github/workflows/ci.yml

@@ -0,0 +1,91 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install package with dev dependencies
+        run: pip install -e ".[dev]"
+
+      - name: Lint (syntax check)
+        run: |
+          # Recursive — covers subpackages, not just src/athanor/*.py top level.
+          find src -name "*.py" -exec python -m py_compile {} +
+
+      - name: Run tests with coverage
+        # Threshold is 45%: current coverage is ~50%, leaving a 5-point
+        # buffer for legitimate test reorgs while still catching significant
+        # regressions. Raise as we add tests — 70% is the eventual goal
+        # for customer-facing code, but we don't want to gate the entire
+        # CI on aspirational targets today.
+        run: |
+          pip install pytest-cov -q
+          pytest tests/ -v --cov=src/athanor --cov-report=term-missing --cov-fail-under=45
+
+  security:
+    runs-on: ubuntu-latest
+    # Doesn't gate the test job — security findings are advisory.
+    # We ship to PyPI; supply chain risk is real but advisories alone
+    # shouldn't block releases. Same threat-model approach as
+    # athanor-builder/SECURITY.md.
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install pip-audit
+        run: pip install pip-audit -q
+
+      - name: Audit declared dependencies
+        # Surface findings as warnings, not hard fail. New critical CVEs
+        # in our dep tree should be flagged but not block an unrelated PR.
+        run: |
+          pip-audit --desc 2>&1 | tee /tmp/audit.log || true
+          if grep -qi "vulnerability\|GHSA-\|CVE-" /tmp/audit.log 2>/dev/null; then
+            echo "::warning::pip-audit found vulnerabilities — see logs above"
+          fi
+        continue-on-error: true
+
+  publish:
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: test
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build tools
+        run: pip install build twine
+
+      - name: Build package
+        run: python -m build
+
+      - name: Check package
+        run: twine check dist/*
+
+      - name: Publish to PyPI
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
+        run: twine upload dist/*

athanor_sdk-0.3.2/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.pytest_cache/
+.mypy_cache/
+*.so
+.env
+.venv/

athanor_sdk-0.3.2/PKG-INFO

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: athanor-sdk
+Version: 0.3.2
+Summary: Formal verification as agentic training signal — CLI + self-hosted runner
+Project-URL: Homepage, https://athanor-ai.com
+Project-URL: Repository, https://github.com/athanor-ai/athanor-sdk
+Author-email: Athanor AI <aidan@athanor-ai.com>
+License: Apache-2.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Provides-Extra: multi-model
+Requires-Dist: litellm>=1.50.0; extra == 'multi-model'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/athanor-ai/athanor-website/main/logo.svg" width="64" height="64" alt="Athanor">
+</p>
+
+<h1 align="center">athanor-ai</h1>
+
+<p align="center">
+  <strong>Lean 4 proof verification as agentic training signal.</strong><br>
+  Turn formal proofs into reward functions. Score agent output with compilers, not judges.<br><br>
+  <a href="https://athanor-ai.com">athanor-ai.com</a>
+</p>
+
+---
+
+Your agent writes code. Then it writes a proof that the code is correct. The Lean 4 compiler checks the proof. The result is a training signal with no ambiguity.
+
+```python
+import athanor
+
+# Verify a Lean 4 proof
+result = athanor.verify_proof("""
+theorem add_comm (a b : Nat) : a + b = b + a := by
+  omega
+""")
+
+print(result.compiles)    # True
+print(result.has_sorry)   # False
+print(result.score)       # 1.0
+```
+
+## Install
+
+```bash
+pip install athanor-ai
+```
+
+## What this solves
+
+You have domain expertise. You know what correct code looks like. You want an AI agent to produce verified solutions, not guesses.
+
+The problem: LLM judges are noisy. Unit tests are brittle. Benchmarks don't produce training signal.
+
+The solution: Lean 4 formal proofs are deterministic, machine-checked, and produce continuous reward signal (full proof = 1.0, partial = 0.35, broken = 0.25).
+
+## Verify proofs
+
+Check if a Lean 4 proof compiles. Detect `sorry` placeholders. Catch banned constructs (`axiom`, `import Mathlib`, `unsafe`).
+
+```python
+from athanor import verify_proof, check_sorry, score_proof
+
+# Full verification with detailed result
+result = verify_proof(proof_code)
+result.compiles      # did it compile?
+result.has_sorry     # any incomplete proof markers?
+result.sorry_count   # how many sorry placeholders?
+result.score         # 0.0 - 1.0
+result.status        # "full_proof" | "partial_proof" | "compile_error" | "banned"
+result.errors        # compiler error messages
+
+# Quick score (just the float)
+score = score_proof(proof_code)  # 1.0, 0.35, 0.25, or 0.0
+
+# Check for sorry without full compilation
+has_sorry, count = check_sorry(proof_code)
+```
+
+Works with local Lean 4 installation or via Docker (`ghcr.io/leanprover/lean4`).
+
+## Score agent output
+
+Pair code with a proof. Score both. Use the result as reward.
+
+```python
+import athanor
+
+env = athanor.make("my-environment", task="my-task")
+env.reset()
+
+result = env.score({
+    "kernel.py": agent_code,
+    "proof.lean": agent_proof,
+})
+
+# Scoring layers:
+# 1. Does the code work? (verifier checks)
+# 2. Does the proof compile? (Lean compiler)
+# 3. Is the proof complete? (no sorry)
+print(result.score)        # combined score
+print(result.lean_status)  # proof status
+```
+
+## Agent retry with verifier feedback
+
+Agent gets the scoring output and tries again. No human in the loop. The verifier feedback is the teacher.
+
+```python
+results = env.run(
+    model="anthropic/claude-sonnet-4-6",
+    api_key="...",
+    max_retries=3,
+    target_score=0.95,
+)
+# Attempt 1: 0.35 (code correct, proof has sorry)
+# Attempt 2: 0.72 (proof compiles, 2 sorry remaining)
+# Attempt 3: 0.98 (full proof, verified)
+```
+
+## RL training
+
+Use proof scores as reward signal in any RL framework.
+
+```python
+from trl import PPOTrainer
+
+env = athanor.make("my-environment")
+trainer = PPOTrainer(
+    reward_fn=lambda completions: env.reward_fn(completions),
+    ...
+)
+```
+
+Compatible with TRL, veRL, NeMo-RL, or any custom training loop.
+
+## Proof scoring
+
+```
+proof_multiplier:
+  1.00  full proof (compiles, no sorry)
+  0.35  partial proof (compiles with sorry)
+  0.25  broken proof (does not compile)
+  0.15  no proof submitted
+  0.00  banned construct (axiom, Mathlib, unsafe)
+```
+
+Partial proofs produce gradient. An agent that proves 4 of 7 theorems scores higher than one that proves 0. This is the training signal.
+
+## Getting environments
+
+The `verify_proof` and `score_proof` functions work standalone with any Lean 4 code. For full environment scoring (code + proof + property tests), contact [athanor-ai.com](https://athanor-ai.com).
+
+## CLI
+
+```bash
+# Container sanity checks — 7 gates including shim re-export + reward-leak probe
+athanor preflight --env <env_slug>
+
+# Batch evaluate all tasks in an environment (or filter/patch)
+athanor evaluate --env hw-cbmc --model anthropic/claude-sonnet-4-6
+athanor evaluate --env hw-cbmc --tasks fix_arb_lock,fix_tlb_ctrl    # subset
+athanor evaluate --env hw-cbmc --patch runs/prev_run1.json          # resume
+
+# Score, solve, lint, estimate
+athanor score --env <env> --task <slug> --file solution.py
+athanor solve --env <env> --task <slug> --model claude-opus-4-6
+athanor lint Proof.lean                   # positional
+athanor estimate --model claude-sonnet-4-6 --tasks 26
+
+# Run/calibrate/stats
+athanor runs --env <env>
+athanor calibrate --run runs/<model>_run1.json
+athanor stats runs/*.json
+athanor compare runs/a.json runs/b.json
+athanor eval-status [env_dir]
+```
+
+Results save incrementally after each task (crash-resilient). `--patch` merges into an existing run file so you can resume interrupted sweeps.
+
+## Requirements
+
+- Python >= 3.9
+- Lean 4 or Docker (for proof verification)
+
+## License
+
+Apache-2.0

athanor_sdk-0.3.2/README.md

@@ -0,0 +1,176 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/athanor-ai/athanor-website/main/logo.svg" width="64" height="64" alt="Athanor">
+</p>
+
+<h1 align="center">athanor-ai</h1>
+
+<p align="center">
+  <strong>Lean 4 proof verification as agentic training signal.</strong><br>
+  Turn formal proofs into reward functions. Score agent output with compilers, not judges.<br><br>
+  <a href="https://athanor-ai.com">athanor-ai.com</a>
+</p>
+
+---
+
+Your agent writes code. Then it writes a proof that the code is correct. The Lean 4 compiler checks the proof. The result is a training signal with no ambiguity.
+
+```python
+import athanor
+
+# Verify a Lean 4 proof
+result = athanor.verify_proof("""
+theorem add_comm (a b : Nat) : a + b = b + a := by
+  omega
+""")
+
+print(result.compiles)    # True
+print(result.has_sorry)   # False
+print(result.score)       # 1.0
+```
+
+## Install
+
+```bash
+pip install athanor-ai
+```
+
+## What this solves
+
+You have domain expertise. You know what correct code looks like. You want an AI agent to produce verified solutions, not guesses.
+
+The problem: LLM judges are noisy. Unit tests are brittle. Benchmarks don't produce training signal.
+
+The solution: Lean 4 formal proofs are deterministic, machine-checked, and produce continuous reward signal (full proof = 1.0, partial = 0.35, broken = 0.25).
+
+## Verify proofs
+
+Check if a Lean 4 proof compiles. Detect `sorry` placeholders. Catch banned constructs (`axiom`, `import Mathlib`, `unsafe`).
+
+```python
+from athanor import verify_proof, check_sorry, score_proof
+
+# Full verification with detailed result
+result = verify_proof(proof_code)
+result.compiles      # did it compile?
+result.has_sorry     # any incomplete proof markers?
+result.sorry_count   # how many sorry placeholders?
+result.score         # 0.0 - 1.0
+result.status        # "full_proof" | "partial_proof" | "compile_error" | "banned"
+result.errors        # compiler error messages
+
+# Quick score (just the float)
+score = score_proof(proof_code)  # 1.0, 0.35, 0.25, or 0.0
+
+# Check for sorry without full compilation
+has_sorry, count = check_sorry(proof_code)
+```
+
+Works with local Lean 4 installation or via Docker (`ghcr.io/leanprover/lean4`).
+
+## Score agent output
+
+Pair code with a proof. Score both. Use the result as reward.
+
+```python
+import athanor
+
+env = athanor.make("my-environment", task="my-task")
+env.reset()
+
+result = env.score({
+    "kernel.py": agent_code,
+    "proof.lean": agent_proof,
+})
+
+# Scoring layers:
+# 1. Does the code work? (verifier checks)
+# 2. Does the proof compile? (Lean compiler)
+# 3. Is the proof complete? (no sorry)
+print(result.score)        # combined score
+print(result.lean_status)  # proof status
+```
+
+## Agent retry with verifier feedback
+
+Agent gets the scoring output and tries again. No human in the loop. The verifier feedback is the teacher.
+
+```python
+results = env.run(
+    model="anthropic/claude-sonnet-4-6",
+    api_key="...",
+    max_retries=3,
+    target_score=0.95,
+)
+# Attempt 1: 0.35 (code correct, proof has sorry)
+# Attempt 2: 0.72 (proof compiles, 2 sorry remaining)
+# Attempt 3: 0.98 (full proof, verified)
+```
+
+## RL training
+
+Use proof scores as reward signal in any RL framework.
+
+```python
+from trl import PPOTrainer
+
+env = athanor.make("my-environment")
+trainer = PPOTrainer(
+    reward_fn=lambda completions: env.reward_fn(completions),
+    ...
+)
+```
+
+Compatible with TRL, veRL, NeMo-RL, or any custom training loop.
+
+## Proof scoring
+
+```
+proof_multiplier:
+  1.00  full proof (compiles, no sorry)
+  0.35  partial proof (compiles with sorry)
+  0.25  broken proof (does not compile)
+  0.15  no proof submitted
+  0.00  banned construct (axiom, Mathlib, unsafe)
+```
+
+Partial proofs produce gradient. An agent that proves 4 of 7 theorems scores higher than one that proves 0. This is the training signal.
+
+## Getting environments
+
+The `verify_proof` and `score_proof` functions work standalone with any Lean 4 code. For full environment scoring (code + proof + property tests), contact [athanor-ai.com](https://athanor-ai.com).
+
+## CLI
+
+```bash
+# Container sanity checks — 7 gates including shim re-export + reward-leak probe
+athanor preflight --env <env_slug>
+
+# Batch evaluate all tasks in an environment (or filter/patch)
+athanor evaluate --env hw-cbmc --model anthropic/claude-sonnet-4-6
+athanor evaluate --env hw-cbmc --tasks fix_arb_lock,fix_tlb_ctrl    # subset
+athanor evaluate --env hw-cbmc --patch runs/prev_run1.json          # resume
+
+# Score, solve, lint, estimate
+athanor score --env <env> --task <slug> --file solution.py
+athanor solve --env <env> --task <slug> --model claude-opus-4-6
+athanor lint Proof.lean                   # positional
+athanor estimate --model claude-sonnet-4-6 --tasks 26
+
+# Run/calibrate/stats
+athanor runs --env <env>
+athanor calibrate --run runs/<model>_run1.json
+athanor stats runs/*.json
+athanor compare runs/a.json runs/b.json
+athanor eval-status [env_dir]
+```
+
+Results save incrementally after each task (crash-resilient). `--patch` merges into an existing run file so you can resume interrupted sweeps.
+
+## Requirements
+
+- Python >= 3.9
+- Lean 4 or Docker (for proof verification)
+
+## License
+
+Apache-2.0