programasweights 0.4.2__tar.gz → 0.4.3__tar.gz

programasweights-0.4.3/.github/workflows/test.yml

@@ -0,0 +1,41 @@
+name: tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install (hermetic deps only)
+        # Install httpx + pytest and the package itself without pulling the heavy
+        # llama-cpp-python build. The hermetic tests below never import the
+        # llama.cpp runtime (it is imported lazily only when running inference).
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install httpx pytest
+          python -m pip install -e . --no-deps
+
+      - name: Run hermetic tests
+        # Scoped to tests that need no network, no model download, and no
+        # PAW_API_KEY. Auth tests (@needs_auth) auto-skip without a key; the
+        # network/model-download tests in test_sdk.py are excluded here and can
+        # be run separately against a live server.
+        run: |
+          pytest \
+            tests/test_cli_auth.py \
+            tests/test_runtime_registry_sdk.py \
+            tests/test_sdk.py::TestInstallAndImport

{programasweights-0.4.2 → programasweights-0.4.3}/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.4.3 (2026-07-06)
+
+- Fix `paw info` / `paw rename` crashing with `AttributeError` when run without
+  `--api-url`/`--api-key` (they read the removed `paw.api_url`/`paw.api_key`
+  module attributes; now resolved via the function-based config API).
+- `--api-url` / `--api-key` now take effect on `compile`, `run`, and `login`
+  (previously accepted but silently ignored on those commands).
+- Docs: reference `paw.get_api_url()` / `paw.get_api_key()` instead of the
+  removed module attributes.
+- Add hermetic CLI auth test suite (`tests/test_cli_auth.py`) and a GitHub
+  Actions CI workflow running it on Python 3.9-3.12.
+
 ## 0.2.4 (2026-04-01)
 
 - Download reliability: asset endpoints return 202 Retry-After when program is still generating, eliminating 404 race conditions

{programasweights-0.4.2 → programasweights-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programasweights
-Version: 0.4.2
+Version: 0.4.3
 Summary: Compile natural language specifications into neural programs that run locally via llama.cpp.
 Project-URL: Homepage, https://programasweights.com
 Project-URL: Repository, https://github.com/programasweights/programasweights-python

{programasweights-0.4.2 → programasweights-0.4.3}/docs/api-reference/python-sdk.md

@@ -128,8 +128,8 @@ export PAW_API_KEY=paw_sk_...
 
 | Name | Description |
 |------|-------------|
-| `paw.api_url` | Base URL for API requests. Default: `https://programasweights.com`. Override with `PAW_API_URL` env var. |
-| `paw.api_key` | API key for authenticated calls. Set via `paw.login()` or `PAW_API_KEY` env var. |
+| `paw.get_api_url()` | Base URL for API requests. Default: `https://programasweights.com`. Override with `PAW_API_URL` env var. |
+| `paw.get_api_key()` | API key for authenticated calls. Set via `paw.login()` or `PAW_API_KEY` env var. |
 | `paw.__version__` | Installed package version string. |
 
 ## Related

{programasweights-0.4.2 → programasweights-0.4.3}/docs/api-reference/rest-api.md

@@ -158,7 +158,12 @@ Successful responses may include:
 | `X-RateLimit-Limit` | Maximum requests per window. |
 | `X-RateLimit-Remaining` | Remaining requests in the current window. |
 
-Clients should backoff when receiving `429 Too Many Requests` and respect `Retry-After` when present.
+Hosted compile quotas:
+
+- Anonymous: **20 compiles/hour**, **1 concurrent compile**
+- Authenticated: **60 compiles/hour**, **2 concurrent compiles**
+
+Hosted server-side endpoints may also enforce additional operational concurrency or safety limits. Clients should back off when receiving `429 Too Many Requests` and respect `Retry-After` when present.
 
 ## Related
 

programasweights-0.4.3/docs/case-studies/alien-taboo.md

@@ -0,0 +1,117 @@
+# Alien Taboo: A Word-Guessing Game on a 0.6B Interpreter
+
+Most of our case studies are about *infrastructure* — log triage, search reranking, agent routing. This one is a game. We wanted to show that a tiny PAW program is enough to power a real, playable, in-browser product, not just internal tooling.
+
+**Try it live:** [programasweights.com/alien](https://programasweights.com/alien) (English) or [programasweights.com/alien-cn](https://programasweights.com/alien-cn) (中文). You describe a secret word, the alien guesses. The alien is one compiled PAW program running on a 0.6B-parameter interpreter — no GPT-4, no API roulette, just one .paw file and a Qwen3 0.6B base model.
+
+## Why this is interesting for PAW
+
+Word-guessing is a textbook *fuzzy function*: easy to describe in one sentence, impossible to write as rules. "Given a player's hint, output the secret word." A keyword matcher would never bridge "fluffy thing that purrs" → `cat`. A retrieval system would force you to enumerate every possible hint. A 32B prompted LLM would work but you can't ship one to a browser-tab user for free.
+
+A 0.6B interpreter with a focused PAW spec is exactly the right size: small enough to run on a single inference server with no per-request cost, expressive enough to recognise the dozens of ways a child might describe "watermelon."
+
+## How we built it
+
+### Attempt 1: One huge spec listing every word
+
+The first instinct was to bake the whole word list into the spec — "the secret word is one of: cat, dog, banana, …" — so the model only ever picks from a known vocabulary.
+
+**Result:** The spec ballooned to thousands of tokens, the compiler timed out, and accuracy *dropped*: the model started biasing toward whichever words appeared earliest in the list regardless of the description.
+
+**Lesson:** Don't dump your domain into the spec. PAW programs work best when the spec teaches a *behaviour* with a few examples, not when it tries to be a database.
+
+### Attempt 2: Free-form generation with a few examples
+
+We replaced the word list with a short instruction and ~15 input/output exemplars covering the diversity of hints (animals, foods, household objects, abstract concepts, multi-word objects).
+
+```
+You are playing a word-guessing game. The user describes a common English
+word in their own words without saying the word itself. Your job is to
+guess the word from the description.
+
+Return ONLY the single word being described. Lowercase. No punctuation,
+no explanation, no extra words.
+
+Input: furry animal that meows and purrs
+Output: cat
+
+Input: yellow curved fruit, monkeys like it
+Output: banana
+
+Input: thing you use to unlock a door, metal, small, has teeth
+Output: key
+
+... (≈12 more)
+```
+
+**Result:** Compiled cleanly, ran in ~80 ms per guess, and produced sensible answers for almost every test description. This is the version shipping today.
+
+**Lesson:** This is the opposite of what we found in our [site navigation](site-navigation.md) and [semantic search](semantic-search.md) studies — there, generation hallucinated and we reframed as classification. Here, generation works because (a) the answer space is implicit (any English noun) so we couldn't classify even if we wanted to, and (b) the answer is short and over-determined by the input. **Generation works when the output is short and the input is rich.**
+
+### Attempt 3: The actual hard part — curating the word bank
+
+With the alien working on the first realistic hint we threw at it, we expected to ship in an afternoon. Instead we spent days on word selection. The reason:
+
+- **Dead words.** "Sundial" is a word every adult knows, but no one can describe it without saying "sun" or "shadow" or "time," all of which produce the wrong guess. A word that never gets solved isn't unfun for the alien — it's unfun for the *player*. Every dead word in the bank is a session-killing dead end.
+- **Fairness.** "Bullfrog" passes the alien's accuracy test but stumps anyone under 12. Mass-appeal games need words a 6-year-old or non-native speaker can describe.
+- **Variety.** A 50-word bank gets boring after two sessions. We wanted ≥300 viable words.
+
+The vetting process became its own pipeline:
+
+1. **Generate candidates** with GPT-5.4 (~4000 raw words across 40 themes).
+2. **Simulate playthroughs** — for each candidate, prompt GPT-5.4-mini to play the role of a human describing the word; route those descriptions through the actual deployed alien program; keep words solved within ≤8 rounds across ≥4 of 5 random-seed trials.
+3. **Filter for commonness** with `wordfreq` (Zipf ≥ 5.0) so kids and ESL players have a fair shot.
+4. **Manual pass** by a human (us) on the survivors to remove anything ambiguous, edgy, or culturally narrow.
+
+The final bank is 361 ultra-common English words. The full vetting script lives at [`server/scripts/vet_alien_words.py`](https://github.com/programasweights/website/blob/main/server/scripts/vet_alien_words.py).
+
+**Lesson:** **The PAW program is usually the easy part of the product.** Treat it as one ingredient. The data, the UI, and the fairness work around the program are typically what take the time.
+
+### The multilingual finale: a Chinese version with one new file
+
+After the English game shipped, we wanted a Chinese version. The intuition was that this would mean fine-tuning a Chinese-specific compiler, retraining the 0.6B interpreter on a Chinese corpus, or at minimum prompt-engineering around tokeniser quirks.
+
+What we actually did:
+
+1. Wrote a new spec — `spec_cn.txt` — in Mandarin, with 20 Chinese hint→word examples.
+2. Compiled it with the same `paw-4b-qwen3-0.6b` compiler.
+3. Pointed a sister `/api/v1/alien-cn/guess` endpoint at the new program ID.
+
+```python
+import programasweights as paw
+
+with open("spec_cn.txt", encoding="utf-8") as f:
+    spec = f.read()
+
+program = paw.compile(spec, compiler="paw-4b-qwen3-0.6b")
+# That's it. program.id is now ready to serve Chinese players.
+```
+
+The first compile produced **67.5% per-description accuracy** and **80% at-least-one-of-two accuracy** on a held-out 20-word Chinese test set, comparable to the English program's accuracy on its English test set. We changed exactly zero lines in the SDK or interpreter.
+
+**Lesson:** **Spec language is just data.** PAW's compiler doesn't carry English-specific assumptions; the only language-aware things in the system are (a) your spec, and (b) any output post-processing your client does (we had to extend the server's "first-word extractor" from `[a-z]+` to also accept `[\u4e00-\u9fff]+`). For a multilingual product, this is several orders of magnitude less work than maintaining a separate stack per language.
+
+## The solution at a glance
+
+The entire alien — both languages — is one PAW function per language plus thin glue:
+
+```python
+import programasweights as paw
+
+alien_en = paw.function(EN_PROGRAM_ID)   # compiled from spec.txt
+alien_cn = paw.function(CN_PROGRAM_ID)   # compiled from spec_cn.txt
+
+def guess(description: str, lang: str) -> str:
+    fn = alien_cn if lang == "zh" else alien_en
+    return fn(description).strip().lower()
+```
+
+Everything else — the timer, the lives, the share card, the leaderboard — is plain product code. No model orchestration, no prompt-management framework, no second LLM behind it.
+
+## Takeaways
+
+- **Generation is the right tool when the output is short and the input is rich.** Classification wins for routing; generation wins for "name this thing." Pick the right one for your task.
+- **The PAW program is usually the easy part.** Most product time goes into data quality, UX, and edge cases — exactly as it would with any function in your codebase.
+- **Use small models to vet content for small models.** Running GPT-5.4-mini in a multi-trial simulation against your deployed PAW program is faster and cheaper than human playtesting, and it scales to thousands of candidates overnight.
+- **Spec language is just data.** A new spec in a new language is a new product, with no SDK or interpreter changes required.
+- **A 0.6B interpreter is enough** for tasks where the input over-determines the output. You don't always need 70B; you need the right factoring.

{programasweights-0.4.2 → programasweights-0.4.3}/mkdocs.yml

@@ -52,6 +52,7 @@ nav:
     - Publishing Programs: hub/publishing-programs.md
     - Feedback & Cases: hub/feedback-cases.md
   - Case Studies:
+    - Alien Taboo (Word Game): case-studies/alien-taboo.md
     - Log Monitoring: case-studies/log-monitoring.md
     - Site Navigation: case-studies/site-navigation.md
     - Semantic Search: case-studies/semantic-search.md

{programasweights-0.4.2 → programasweights-0.4.3}/programasweights/__init__.py

@@ -27,7 +27,7 @@ try:
     from importlib.metadata import version as _meta_version
     __version__ = _meta_version("programasweights")
 except Exception:
-    __version__ = "0.4.2"
+    __version__ = "0.4.3"
 
 from .config import get_api_url, get_api_key, set_api_key
 

{programasweights-0.4.2 → programasweights-0.4.3}/programasweights/cli.py

@@ -14,15 +14,23 @@ All commands support --json for structured output (agent-friendly).
 
 import argparse
 import json
+import os
 import sys
 
 
+def _apply_auth_overrides(args):
+    """Let the global --api-url/--api-key flags take effect on commands that go
+    through the high-level ``paw.compile()``/``paw.function()``/``paw.login()``
+    paths, which resolve credentials from the environment/config only."""
+    if getattr(args, "api_url", None):
+        os.environ["PAW_API_URL"] = args.api_url
+    if getattr(args, "api_key", None):
+        os.environ["PAW_API_KEY"] = args.api_key
+
+
 def cmd_compile(args):
     import programasweights as paw
-    if args.api_url:
-        paw.api_url = args.api_url
-    if args.api_key:
-        paw.api_key = args.api_key
+    _apply_auth_overrides(args)
 
     if not args.json:
         print(f"Compiling: {args.spec[:80]}...")
@@ -63,10 +71,7 @@ def cmd_compile(args):
 
 def cmd_run(args):
     import programasweights as paw
-    if args.api_url:
-        paw.api_url = args.api_url
-    if args.api_key:
-        paw.api_key = args.api_key
+    _apply_auth_overrides(args)
 
     fn = paw.function(
         args.program, verbose=args.verbose,
@@ -82,22 +87,15 @@ def cmd_run(args):
 
 def cmd_login(args):
     import programasweights as paw
-    if args.api_url:
-        paw.api_url = args.api_url
+    _apply_auth_overrides(args)
     paw.login(args.key)
     return 0
 
 
 def cmd_rename(args):
-    import programasweights as paw
-    if args.api_url:
-        paw.api_url = args.api_url
-    if args.api_key:
-        paw.api_key = args.api_key
-
     import httpx
     from programasweights.client import PAWClient
-    client = PAWClient(api_url=paw.api_url, api_key=paw.api_key)
+    client = PAWClient(api_url=args.api_url, api_key=args.api_key)
 
     resp = httpx.patch(
         f"{client._api_url}/api/v1/programs/{args.program}",
@@ -120,14 +118,8 @@ def cmd_rename(args):
 
 
 def cmd_info(args):
-    import programasweights as paw
-    if args.api_url:
-        paw.api_url = args.api_url
-    if args.api_key:
-        paw.api_key = args.api_key
-
     from programasweights.client import PAWClient
-    client = PAWClient(api_url=paw.api_url, api_key=paw.api_key)
+    client = PAWClient(api_url=args.api_url, api_key=args.api_key)
 
     try:
         meta = client.get_program_meta(args.program)

{programasweights-0.4.2 → programasweights-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "programasweights"
-version = "0.4.2"
+version = "0.4.3"
 description = "Compile natural language specifications into neural programs that run locally via llama.cpp."
 readme = "PYPI_README.md"
 requires-python = ">=3.9"

programasweights-0.4.3/tests/test_cli_auth.py

@@ -0,0 +1,186 @@
+"""
+CLI authentication plumbing tests.
+
+These are hermetic: no network, no model load. They cover two classes of bug:
+
+1. Regression guard for the AttributeError crash fixed in PR #1 -- `paw info`
+   and `paw rename` used to read the removed module attributes
+   `paw.api_url`/`paw.api_key` and crashed when no flags were given.
+
+2. `--api-url`/`--api-key` must actually take effect on `compile`, `run`, and
+   `login`. Before the 0.4.3 fix these were global flags that the high-level
+   `paw.compile()`/`paw.function()`/`paw.login()` paths silently ignored
+   (they only read env/config). The flag-plumbing tests below fail on that
+   older behavior and pass once the flags are wired through the environment.
+"""
+
+from types import SimpleNamespace
+
+import pytest
+
+import programasweights as paw
+from programasweights import cli, config
+import programasweights.client as paw_client
+
+
+class FakeProgram:
+    id = "prog123"
+    slug = None
+    status = "ready"
+    error = None
+    timings = None
+    version = 1
+    version_action = "created"
+
+
+def _install_fake_client(monkeypatch, sink):
+    """Replace PAWClient with a fake that records the api_url/api_key it was
+    constructed with, and returns canned data instead of hitting the network."""
+
+    class FakeClient:
+        def __init__(self, api_url=None, api_key=None):
+            sink["api_url"] = api_url
+            sink["api_key"] = api_key
+            self._api_url = (api_url or "https://programasweights.com").rstrip("/")
+            self._api_key = api_key
+
+        def _headers(self):
+            return {"Content-Type": "application/json"}
+
+        def get_program_meta(self, program):
+            return {"id": program, "spec": "canned"}
+
+        def compile(self, *a, **k):
+            return FakeProgram()
+
+    monkeypatch.setattr(paw_client, "PAWClient", FakeClient)
+    return sink
+
+
+@pytest.fixture(autouse=True)
+def _hermetic_env(monkeypatch):
+    # Ignore any real ~/.config/programasweights/config.json and env so the
+    # only source of api_url/api_key is what the command threads through.
+    monkeypatch.setattr(config, "_load_config", lambda: {})
+    monkeypatch.delenv("PAW_API_KEY", raising=False)
+    monkeypatch.delenv("PAW_API_URL", raising=False)
+
+
+# ── Regression guards: info/rename must not crash without flags ──
+
+
+def test_cmd_info_no_flags_no_attributeerror(monkeypatch):
+    sink = _install_fake_client(monkeypatch, {})
+    args = SimpleNamespace(program="prog123", api_url=None, api_key=None, json=True)
+    rc = cli.cmd_info(args)  # crashed with AttributeError before PR #1
+    assert rc == 0
+    assert sink["api_url"] is None and sink["api_key"] is None
+
+
+def test_cmd_rename_no_flags_no_attributeerror(monkeypatch):
+    sink = _install_fake_client(monkeypatch, {})
+
+    import httpx
+
+    class FakeResp:
+        def raise_for_status(self):
+            return None
+
+        def json(self):
+            return {"slug": "new-slug"}
+
+    monkeypatch.setattr(httpx, "patch", lambda *a, **k: FakeResp())
+    args = SimpleNamespace(
+        program="prog123", new_slug="new-slug", api_url=None, api_key=None, json=True
+    )
+    rc = cli.cmd_rename(args)  # crashed with AttributeError before PR #1
+    assert rc == 0
+    assert sink["api_url"] is None and sink["api_key"] is None
+
+
+def test_cmd_info_honors_flags(monkeypatch):
+    sink = _install_fake_client(monkeypatch, {})
+    args = SimpleNamespace(
+        program="prog123",
+        api_url="http://test.local",
+        api_key="paw_sk_test",
+        json=True,
+    )
+    cli.cmd_info(args)
+    assert sink["api_url"] == "http://test.local"
+    assert sink["api_key"] == "paw_sk_test"
+
+
+# ── Flag plumbing: compile/run/login must honor --api-url/--api-key ──
+
+
+def test_apply_auth_overrides_sets_env(monkeypatch):
+    cli._apply_auth_overrides(
+        SimpleNamespace(api_url="http://test.local", api_key="paw_sk_test")
+    )
+    assert config.get_api_url() == "http://test.local"
+    assert config.get_api_key() == "paw_sk_test"
+
+
+def test_apply_auth_overrides_ignores_absent(monkeypatch):
+    cli._apply_auth_overrides(SimpleNamespace(api_url=None, api_key=None))
+    # Falls back to default url, no key.
+    assert config.get_api_url() == "https://programasweights.com"
+    assert config.get_api_key() is None
+
+
+def test_compile_flag_plumbing(monkeypatch):
+    sink = _install_fake_client(monkeypatch, {})
+    args = SimpleNamespace(
+        spec="Classify sentiment as positive or negative.",
+        compiler=None,
+        slug=None,
+        private=False,
+        api_url="http://test.local",
+        api_key="paw_sk_test",
+        json=True,
+    )
+    cli.cmd_compile(args)
+    # The flag must reach the client through get_api_url()/get_api_key().
+    assert sink["api_url"] == "http://test.local"
+    assert sink["api_key"] == "paw_sk_test"
+
+
+def test_run_flag_plumbing(monkeypatch):
+    seen = {}
+
+    def fake_function(program_id, **kwargs):
+        seen["api_url"] = config.get_api_url()
+        seen["api_key"] = config.get_api_key()
+        return lambda *a, **k: "ok"
+
+    monkeypatch.setattr(paw, "function", fake_function)
+    args = SimpleNamespace(
+        program="prog123",
+        input="hello",
+        max_tokens=512,
+        temperature=0.0,
+        verbose=False,
+        api_url="http://test.local",
+        api_key="paw_sk_test",
+        json=True,
+    )
+    cli.cmd_run(args)
+    assert seen["api_url"] == "http://test.local"
+    assert seen["api_key"] == "paw_sk_test"
+
+
+def test_login_flag_plumbing(monkeypatch):
+    seen = {}
+
+    def fake_login(key=None):
+        seen["api_url"] = config.get_api_url()
+        seen["key"] = key
+
+    monkeypatch.setattr(paw, "login", fake_login)
+    args = SimpleNamespace(
+        key="paw_sk_test", api_url="http://test.local", api_key=None
+    )
+    cli.cmd_login(args)
+    assert seen["api_url"] == "http://test.local"
+    assert seen["key"] == "paw_sk_test"

{programasweights-0.4.2 → programasweights-0.4.3}/tests/test_sdk.py

@@ -291,31 +291,29 @@ class TestAuth:
     def test_compile_with_slug_authenticated(self):
         import time
         slug = f"test-sdk-{int(time.time()) % 100000}"
-        old_key = paw.api_key
-        try:
-            paw.api_key = API_KEY
-            program = paw.compile(
-                "Classify text as positive or negative sentiment.",
-                slug=slug,
-            )
-            assert program.id
-            assert program.slug
-            assert slug in program.slug
-        finally:
-            paw.api_key = old_key
+        program = paw.compile(
+            "Classify text as positive or negative sentiment.",
+            slug=slug,
+        )
+        assert program.id
+        assert program.slug
+        assert slug in program.slug
 
     @needs_auth
     def test_compile_with_slug_bad_key(self):
-        old_key = paw.api_key
+        old_key = os.environ.get("PAW_API_KEY")
+        os.environ["PAW_API_KEY"] = "paw_sk_invalid_key_12345"
         try:
-            paw.api_key = "paw_sk_invalid_key_12345"
             with pytest.raises(Exception):
                 paw.compile(
                     "Classify text as positive or negative sentiment.",
                     slug="should-fail-auth",
                 )
         finally:
-            paw.api_key = old_key
+            if old_key is None:
+                del os.environ["PAW_API_KEY"]
+            else:
+                os.environ["PAW_API_KEY"] = old_key
 
     @needs_auth
     def test_cli_compile_with_api_key_flag(self):
@@ -336,34 +334,19 @@ class TestAuth:
 class TestSlugValidation:
     @needs_auth
     def test_slug_too_short(self):
-        old_key = paw.api_key
-        try:
-            paw.api_key = API_KEY
-            with pytest.raises(Exception) as exc_info:
-                paw.compile("Classify text.", slug="x")
-            assert "422" in str(exc_info.value) or "invalid" in str(exc_info.value).lower()
-        finally:
-            paw.api_key = old_key
+        with pytest.raises(Exception) as exc_info:
+            paw.compile("Classify text.", slug="x")
+        assert "422" in str(exc_info.value) or "invalid" in str(exc_info.value).lower()
 
     @needs_auth
     def test_slug_invalid_characters(self):
-        old_key = paw.api_key
-        try:
-            paw.api_key = API_KEY
-            with pytest.raises(Exception):
-                paw.compile("Classify text.", slug="BAD SLUG!")
-        finally:
-            paw.api_key = old_key
+        with pytest.raises(Exception):
+            paw.compile("Classify text.", slug="BAD SLUG!")
 
     @needs_auth
     def test_slug_with_uppercase_rejected(self):
-        old_key = paw.api_key
-        try:
-            paw.api_key = API_KEY
-            with pytest.raises(Exception):
-                paw.compile("Classify text.", slug="MyProgram")
-        finally:
-            paw.api_key = old_key
+        with pytest.raises(Exception):
+            paw.compile("Classify text.", slug="MyProgram")
 
 
 # ── Phase 10: Privacy ──
@@ -373,36 +356,26 @@ class TestPrivacy:
     @needs_auth
     def test_compile_private_program(self):
         import httpx
-        old_key = paw.api_key
-        try:
-            paw.api_key = API_KEY
-            program = paw.compile("Private test program for counting vowels.", public=False)
-            assert program.id
-
-            resp = httpx.get(
-                f"{paw.api_url}/api/v1/programs/{program.id}",
-                timeout=10.0,
-            )
-            assert resp.status_code == 404, "Private program should return 404 to unauthenticated users"
-        finally:
-            paw.api_key = old_key
+        program = paw.compile("Private test program for counting vowels.", public=False)
+        assert program.id
+
+        resp = httpx.get(
+            f"{paw.get_api_url()}/api/v1/programs/{program.id}",
+            timeout=10.0,
+        )
+        assert resp.status_code == 404, "Private program should return 404 to unauthenticated users"
 
     @needs_auth
     def test_compile_public_default(self):
         import httpx
-        old_key = paw.api_key
-        try:
-            paw.api_key = API_KEY
-            program = paw.compile("Public test program for counting words.")
-            assert program.id
-
-            resp = httpx.get(
-                f"{paw.api_url}/api/v1/programs/{program.id}",
-                timeout=10.0,
-            )
-            assert resp.status_code == 200, "Public program should be accessible"
-        finally:
-            paw.api_key = old_key
+        program = paw.compile("Public test program for counting words.")
+        assert program.id
+
+        resp = httpx.get(
+            f"{paw.get_api_url()}/api/v1/programs/{program.id}",
+            timeout=10.0,
+        )
+        assert resp.status_code == 200, "Public program should be accessible"
 
 
 # ── Phase 11: CLI rename ──
@@ -412,24 +385,19 @@ class TestCLIRename:
     @needs_auth
     def test_cli_rename(self):
         import time
-        old_key = paw.api_key
-        try:
-            paw.api_key = API_KEY
-            program = paw.compile("Test rename program for validation.")
-            slug = f"rename-test-{int(time.time()) % 100000}"
-
-            result = subprocess.run(
-                [sys.executable, "-m", "programasweights.cli",
-                 "--api-key", API_KEY,
-                 "rename", program.id, slug, "--json"],
-                capture_output=True, text=True,
-            )
-            assert result.returncode == 0
-            data = json.loads(result.stdout)
-            assert data.get("slug")
-            assert slug in data["slug"]
-        finally:
-            paw.api_key = old_key
+        program = paw.compile("Test rename program for validation.")
+        slug = f"rename-test-{int(time.time()) % 100000}"
+
+        result = subprocess.run(
+            [sys.executable, "-m", "programasweights.cli",
+             "--api-key", API_KEY,
+             "rename", program.id, slug, "--json"],
+            capture_output=True, text=True,
+        )
+        assert result.returncode == 0
+        data = json.loads(result.stdout)
+        assert data.get("slug")
+        assert slug in data["slug"]
 
     @needs_auth
     def test_cli_compile_private(self):
@@ -481,30 +449,20 @@ class TestFunctionAcceptsProgram:
 class TestListPrograms:
     @needs_auth
     def test_list_programs_returns_dict(self):
-        old_key = paw.api_key
-        try:
-            paw.api_key = API_KEY
-            result = paw.list_programs()
-            assert isinstance(result, dict)
-            assert "programs" in result
-            assert "total" in result
-            assert isinstance(result["programs"], list)
-        finally:
-            paw.api_key = old_key
+        result = paw.list_programs()
+        assert isinstance(result, dict)
+        assert "programs" in result
+        assert "total" in result
+        assert isinstance(result["programs"], list)
 
     @needs_auth
     def test_list_programs_has_entries(self):
-        old_key = paw.api_key
-        try:
-            paw.api_key = API_KEY
-            result = paw.list_programs(per_page=5)
-            assert len(result["programs"]) <= 5
-            if result["programs"]:
-                p = result["programs"][0]
-                assert "id" in p
-                assert "spec" in p
-        finally:
-            paw.api_key = old_key
+        result = paw.list_programs(per_page=5)
+        assert len(result["programs"]) <= 5
+        if result["programs"]:
+            p = result["programs"][0]
+            assert "id" in p
+            assert "spec" in p
 
 
 class TestStderrSuppression: