programasweights 0.2.1__tar.gz → 0.2.2__tar.gz

programasweights-0.2.2/.cursor/rules/sdk-publishing.mdc

@@ -0,0 +1,53 @@
+---
+description: SDK publishing workflow for Python and JavaScript packages
+alwaysApply: true
+---
+
+# SDK Publishing Rules
+
+## Public repos are the source of truth for published packages
+
+- **Python SDK**: https://github.com/programasweights/programasweights-python
+- **JS SDK**: https://github.com/programasweights/programasweights-js
+
+## Release workflow
+
+1. Make changes in the public repo (feature branch -> PR -> main)
+2. Bump version in `pyproject.toml` / `__init__.py` (Python) or `package.json` (JS)
+3. Run tests: `bash tests/test_sdk.sh` (Python) or `npm test && npx playwright test` (JS)
+4. Tag: `git tag -a vX.Y.Z -m "Release vX.Y.Z"`
+5. Build and publish from the tagged commit:
+   - Python: `python -m build && twine upload dist/*`
+   - JS: `npm publish --access public`
+6. Push tag: `git push origin vX.Y.Z`
+7. Verify: compare published package with repo (`pip download` / `npm pack` then diff)
+
+## Never do
+
+- Do NOT publish from the monorepo (`paw_discrete/programasweights/`) -- always use the public repos
+- Do NOT publish without tagging first
+- Do NOT forget to sync the monorepo after publishing (if changes originated there)
+- Do NOT use rsync/scp for code deployment -- always git push + git pull
+- Do NOT deploy to server without committing to git first
+
+## All repos are under github.com/programasweights/
+
+- `website` -- monorepo deployed to server (git push website main)
+- `programasweights-python` -- Python SDK (published to PyPI)
+- `programasweights-js` -- JS SDK (published to npm)
+
+## Wheel index
+
+Pre-built `llama-cpp-python` wheels are hosted at `pypi.programasweights.com`.
+Install command: `pip install programasweights --extra-index-url https://pypi.programasweights.com/simple/`
+If `llama-cpp-python` releases a new version, rebuild wheels on our servers and update the index.
+
+## PyPI credentials
+
+- Token in `~/.bashrc` on server 31.22.104.226 as `PYPI_API_TOKEN`
+- Upload via: `twine upload --username __token__ --password $PYPI_API_TOKEN`
+
+## npm credentials
+
+- Token in `~/.bashrc` on server 31.22.104.226 as `NPM_TOKEN`
+- Granular access token with publish permissions for `@programasweights` scope

{programasweights-0.2.1 → programasweights-0.2.2}/.cursor/rules/vllm-deployment.mdc

@@ -13,14 +13,26 @@ All server code lives at `/root/paw-website/` (git clone of `programasweights/we
 
 **Deployment (the ONLY way to update code):**
 ```bash
-# Local: push changes
-git push origin main
+# Local: commit and push to the website repo
+git push website main
 
-# Server: pull and restart
-cd /root/paw-website && git pull
-cd server && bash scripts/start_all.sh
+# Server: pull, build frontend, restart backend
+cd /root/paw-website && git fetch origin && git reset --hard origin/main
+cd web-app/frontend && npm run build && rsync -a --delete dist/ /data/paw-frontend/
+cd /root/paw-website/server && bash scripts/restart.sh
 ```
 
+**IMPORTANT:** `dist/` is in `.gitignore`. Frontend must be built on the server after pull.
+
+**Repos (all under github.com/programasweights/):**
+- `website` -- monorepo (server, frontend, web-sdk, docs). Deployed to server.
+- `programasweights-python` -- Python SDK source. Published to PyPI.
+- `programasweights-js` -- JS SDK source. Published to npm.
+
+**Local remote setup:**
+- `origin` = `yuntian-group/programasweights` (private monorepo)
+- `website` = `programasweights/website` (public, deployed to server)
+
 **NEVER use rsync or scp for code.** Model weights use scp between servers.
 
 ### GPU Layout

programasweights-0.2.2/AGENTS.md

@@ -0,0 +1,194 @@
+# ProgramAsWeights (PAW)
+
+PAW compiles natural language specifications into tiny neural functions that run locally. Each function takes a single text input and returns a single text output. Use PAW when you need fuzzy text processing — classification, extraction, format repair, search, triage — that regex can't handle but a full LLM is overkill for.
+
+Website: https://programasweights.com
+Docs: https://programasweights.readthedocs.io
+
+## Install
+
+```bash
+pip install programasweights --extra-index-url https://pypi.programasweights.com/simple/
+```
+
+## Usage
+
+```python
+import programasweights as paw
+
+# Use a pre-compiled function (downloads once, runs locally forever)
+# "email-triage" is an official pre-compiled program (slug)
+fn = paw.function("email-triage")
+fn("Urgent: server is down!")  # "immediate"
+fn("Newsletter: spring picnic")  # "wait"
+
+# Compile your own from a description
+program = paw.compile(
+    "Fix malformed JSON: repair missing quotes and trailing commas",
+    compiler="paw-4b-qwen3-0.6b"  # or "paw-4b-gpt2" for smaller/faster
+)
+fn = paw.function(program.id)
+fn("{name: 'Alice',}")  # '{"name": "Alice"}'
+
+# Or compile and load in one step
+fn = paw.compile_and_load("Classify sentiment as positive or negative")
+fn("I love this!")  # "positive"
+```
+
+## Two Compilers
+
+| | Standard (Qwen3 0.6B) | Compact (GPT-2 124M) |
+|---|---|---|
+| Compiler name | `paw-4b-qwen3-0.6b` | `paw-4b-gpt2` |
+| Accuracy | Higher | Lower |
+| Base model size | 594 MB | 105 MB |
+| Program size | ~22 MB | ~5 MB |
+| Inference speed | ~90ms (server) | ~50ms (server) |
+| Runs in browser | No | Yes (must use this compiler) |
+
+Default is Standard. Use Compact when you need smaller files or browser deployment.
+
+## When to Use PAW
+
+- **Fuzzy search** — typo-tolerant matching, semantic search, near-duplicate detection
+- **Format repair** — fix broken JSON, normalize dates, repair malformed inputs
+- **Classification** — sentiment, urgency, categories defined in your own words
+- **Extraction** — emails, names, dates from messy unstructured text
+- **Log triage** — extract errors from verbose output, filter noise
+- **Intent routing** — map user descriptions to the closest URL, menu item, or setting
+- **Agent preprocessing** — parse tool calls, validate outputs, route tasks
+
+## Writing Good Specs
+
+The spec is the most important input. It defines what your function does.
+
+**Structure:** Description + examples. Use `Input: ... Output: ...` format.
+
+```python
+fn = paw.compile_and_load("""
+Classify user intent. Return ONLY one of: search, create, delete, other.
+
+Input: Find the latest report
+Output: search
+
+Input: Make a new folder
+Output: create
+
+Input: Remove old backups
+Output: delete
+
+Input: What time is it
+Output: other
+""")
+```
+
+**Tips:**
+- **5-10 examples** is the sweet spot. More helps for ambiguous tasks.
+- For classifiers, add **negative examples** ("Input: ... Output: NONE") to reduce false positives.
+- Explicitly state output constraints: "Return ONLY one of: X, Y, Z"
+- Spec + examples must fit in ~2048 tokens total (~1500 words).
+- Each function is stateless: one input, one output. No conversation history.
+
+## Browser / JavaScript SDK
+
+Programs compiled with `paw-4b-gpt2` also run entirely in the browser via WebAssembly.
+
+```bash
+npm install @programasweights/web
+```
+
+```javascript
+import paw from '@programasweights/web';
+
+const fn = await paw.function('programasweights/email-triage');
+const result = await fn('Urgent: server is down!');
+// result: "immediate"
+```
+
+## Authentication (optional)
+
+Everything works without authentication. Sign in for higher rate limits and program naming.
+
+```bash
+export PAW_API_KEY=paw_sk_...
+```
+
+Generate API keys at https://programasweights.com/settings.
+
+| | Anonymous | Authenticated |
+|---|---|---|
+| Compile rate limit | 20/hr | 60/hr |
+| Name programs (slugs) | No | Yes |
+
+## CLI
+
+```bash
+paw compile --spec "Classify sentiment" --json
+paw run --program <program_id> --input "I love this!" --json
+paw info <program_id>             # show program metadata
+paw rename <program_id> my-slug   # name a program (requires auth)
+paw login                         # save API key
+```
+
+`--json` gives structured output. Example:
+
+```json
+{"program_id": "a6b454023d41ac9ca845", "slug": null, "status": "ready", "timings": {"total_ms": 2800}}
+```
+
+## Full API Reference
+
+```python
+# Compile a spec into a neural program
+program = paw.compile(
+    spec,                               # natural language specification (str)
+    compiler="paw-4b-qwen3-0.6b",      # compiler model name
+    slug=None,                          # optional: URL-safe handle (requires auth)
+    public=True,                        # list on public hub
+)
+# Returns: Program(id: str, slug: str|None, status: str, timings: dict, error: str|None)
+
+# Load a program for local inference
+fn = paw.function(program)              # accepts Program object, hash ID, or slug
+fn = paw.function("a6b454023d41ac9ca845")  # by hash
+fn = paw.function("da03/my-classifier")    # by slug
+
+# The callable signature:
+result: str = fn(input_text: str, max_tokens=512, temperature=0.0)
+
+# Compile and load in one step
+fn = paw.compile_and_load(spec, compiler="paw-4b-qwen3-0.6b")
+
+# List your programs (requires auth)
+programs = paw.list_programs(sort="recent", per_page=20)
+
+# Save API key
+paw.login()
+```
+
+## Common Errors
+
+| Error | Cause | Fix |
+|-------|-------|-----|
+| `httpx.HTTPStatusError: 404` on download | Program still uploading to CDN | SDK retries automatically. If persistent, recompile. |
+| `httpx.HTTPStatusError: 422` on compile | Spec too short (<10 chars) or too long | Adjust spec length. |
+| `httpx.HTTPStatusError: 429` | Rate limit exceeded | Wait, or sign in for higher limits. |
+| `FileNotFoundError: No prompt_template.txt` | Program not cached and download failed | Check network; the program may not exist. |
+
+## Performance Notes
+
+- **First call**: ~500ms (loads base model into memory). Subsequent calls: ~50-90ms.
+- **Base model shared**: Multiple functions share one 594 MB model in memory. Each LoRA adapter adds ~22 MB.
+- **Thread-safe**: Same function can be called from multiple threads.
+- **Blocking**: Each `fn()` call blocks until inference completes.
+- **Cache location**: `~/.cache/programasweights/`. Set `PAW_CACHE_DIR` to override.
+- **Offline**: After first download, functions work without internet.
+
+## Browse Programs
+
+https://programasweights.com/hub
+
+## Add PAW to Your Project
+
+Copy this file into your project as AGENTS.md:
+https://programasweights.com/agents

{programasweights-0.2.1 → programasweights-0.2.2}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.2.2 (2026-03-19)
+
+- Add `paw.compile_and_load()` convenience method (compile + load in one call)
+- `paw.function()` now accepts a `Program` object directly (not just string ID)
+- Add `paw.list_programs()` for authenticated users to list their programs
+- Suppress `llama.cpp` stderr noise by default; use `verbose=True` to enable
+- Rewritten AGENTS.md with spec-writing tips, full API reference, common errors, and performance notes
+
 ## 0.2.0 (2026-04-01)
 
 First public release.

{programasweights-0.2.1 → programasweights-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programasweights
-Version: 0.2.1
+Version: 0.2.2
 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
@@ -58,6 +58,10 @@ program = paw.compile(
 )
 fn = paw.function(program.slug)    # or paw.function(program.id)
 fn("{name: 'Alice',}")  # '{"name": "Alice"}'
+
+# Or compile and load in one step
+fn = paw.compile_and_load("Classify sentiment as positive or negative")
+fn("I love this!")  # "positive"
 ```
 
 ## Two Compilers

{programasweights-0.2.1 → programasweights-0.2.2}/PYPI_README.md

@@ -28,6 +28,10 @@ program = paw.compile(
 )
 fn = paw.function(program.slug)    # or paw.function(program.id)
 fn("{name: 'Alice',}")  # '{"name": "Alice"}'
+
+# Or compile and load in one step
+fn = paw.compile_and_load("Classify sentiment as positive or negative")
+fn("I love this!")  # "positive"
 ```
 
 ## Two Compilers

{programasweights-0.2.1 → programasweights-0.2.2}/docs/api-reference/python-sdk.md

@@ -24,7 +24,7 @@ Loads a compiled program and returns a callable. Downloads the program and base
 
 | Parameter | Description |
 |-----------|-------------|
-| `name_or_id` | Program hash ID (e.g. `a6b454023d41ac9ca845`), slug (e.g. `da03/my-classifier`), or official shorthand (e.g. `email-triage`). |
+| `name_or_id` | A `Program` object, hash ID (e.g. `a6b454023d41ac9ca845`), slug (e.g. `da03/my-classifier`), or official shorthand (e.g. `email-triage`). |
 | `n_ctx` | Context length for the local runtime (default `2048`). |
 | `n_gpu_layers` | GPU layers to offload (`0` = CPU-only, `-1` = all). Set `PAW_GPU_LAYERS` env var as default. |
 | `verbose` | Enable verbose logging (default `False`). |
@@ -76,6 +76,36 @@ Compiles a natural language spec on the server. Returns a `Program` object.
 | `timings` | Timing metadata from the server. |
 | `error` | Error message when compilation fails. |
 
+## `paw.compile_and_load`
+
+```python
+fn = paw.compile_and_load(spec, compiler="paw-4b-qwen3-0.6b", **kwargs)
+```
+
+Convenience method that compiles a spec and immediately loads the result for local inference. Equivalent to `paw.function(paw.compile(spec, ...).id)`. Returns a callable.
+
+Accepts all the same parameters as `paw.compile`.
+
+## `paw.list_programs`
+
+```python
+result = paw.list_programs(sort="recent", per_page=20)
+```
+
+Returns a dict with the authenticated user's compiled programs. Requires authentication.
+
+| Parameter | Description |
+|-----------|-------------|
+| `sort` | Sort order: `"recent"` (default), `"votes"`, `"recommended"`. |
+| `per_page` | Number of results per page (default `20`). |
+
+**Return value** -- dict:
+
+| Key | Description |
+|-----|-------------|
+| `programs` | List of program dicts with `id`, `spec`, `name`, `compiler`, etc. |
+| `total` | Total number of programs. |
+
 ## `paw.login`
 
 ```python

{programasweights-0.2.1 → programasweights-0.2.2}/programasweights/__init__.py

@@ -22,7 +22,7 @@ API reference:
     paw.api_key                API key (set via login() or PAW_API_KEY env var)
 """
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 
 from .config import get_api_url, get_api_key, set_api_key
 
@@ -72,7 +72,7 @@ def compile(
 
 
 def function(
-    program_id: str,
+    program_id,
     n_ctx: int = 2048,
     n_gpu_layers: int | None = None,
     verbose: bool = False,
@@ -83,7 +83,7 @@ def function(
     Subsequent calls use the local cache.
 
     Args:
-        program_id: The program ID from ``paw.compile()``.
+        program_id: Program ID (str), slug, or a ``Program`` object from compile().
         n_ctx: Context window size for llama.cpp.
         n_gpu_layers: GPU layers (-1 = all, 0 = CPU only). Defaults to CPU.
             Set ``PAW_GPU_LAYERS`` env var or pass explicitly for GPU acceleration.
@@ -96,7 +96,12 @@ def function(
         >>> fn = paw.function("email-triage")
         >>> fn("Urgent: the server is down!")
         'immediate'
+
+        >>> program = paw.compile("Classify sentiment")
+        >>> fn = paw.function(program)  # accepts Program object directly
     """
+    if hasattr(program_id, 'id'):
+        program_id = program_id.slug or program_id.id
     import os
     import re
     from .cache import is_program_cached, get_program_dir, get_cached_slug, save_slug_mapping
@@ -175,9 +180,60 @@ def login(key: str | None = None):
     print("You can also set the PAW_API_KEY environment variable.")
 
 
+def compile_and_load(
+    spec: str,
+    compiler: str = "paw-4b-qwen3-0.6b",
+    n_ctx: int = 2048,
+    n_gpu_layers: int | None = None,
+    verbose: bool = False,
+    **compile_kwargs,
+):
+    """Compile a spec and immediately load it for local inference.
+
+    Convenience wrapper that combines ``paw.compile()`` and ``paw.function()``
+    into a single call.
+
+    Args:
+        spec: Natural language specification.
+        compiler: Compiler model name.
+        n_ctx: Context window size for llama.cpp.
+        n_gpu_layers: GPU layers (-1 = all, 0 = CPU only).
+        verbose: Print llama.cpp debug output.
+        **compile_kwargs: Additional args passed to compile (slug, public, etc.)
+
+    Returns:
+        A callable ``PawFunction``.
+
+    Example:
+        >>> fn = paw.compile_and_load("Classify sentiment as positive or negative")
+        >>> fn("I love this!")
+        'positive'
+    """
+    program = compile(spec, compiler=compiler, **compile_kwargs)
+    return function(program, n_ctx=n_ctx, n_gpu_layers=n_gpu_layers, verbose=verbose)
+
+
+def list_programs(sort: str = "recent", per_page: int = 20, page: int = 1) -> dict:
+    """List your compiled programs. Requires authentication (PAW_API_KEY).
+
+    Returns:
+        Dict with ``programs`` (list), ``total``, ``page``, ``per_page``.
+
+    Example:
+        >>> programs = paw.list_programs()
+        >>> for p in programs["programs"]:
+        ...     print(p["id"], p["name"])
+    """
+    from .client import PAWClient
+    client = PAWClient(api_url=api_url, api_key=api_key)
+    return client.list_programs(sort=sort, per_page=per_page, page=page)
+
+
 __all__ = [
     "compile",
+    "compile_and_load",
     "function",
+    "list_programs",
     "login",
     "api_url",
     "api_key",

{programasweights-0.2.1 → programasweights-0.2.2}/programasweights/client.py

@@ -108,18 +108,25 @@ class PAWClient:
         """Download a .paw bundle to the local cache.
 
         Returns the path to the extracted program directory.
+        Retries on 404 since freshly compiled programs may still be uploading.
         """
         program_dir = config.get_programs_dir() / program_id
         if (program_dir / "prompt_template.txt").exists():
             return program_dir
 
-        resp = httpx.get(
-            f"{self._api_url}/api/v1/programs/{program_id}/download",
-            headers=self._headers(),
-            timeout=60.0,
-            follow_redirects=True,
-        )
-        resp.raise_for_status()
+        max_retries = 10
+        for attempt in range(max_retries):
+            resp = httpx.get(
+                f"{self._api_url}/api/v1/programs/{program_id}/download",
+                headers=self._headers(),
+                timeout=60.0,
+                follow_redirects=True,
+            )
+            if resp.status_code == 404 and attempt < max_retries - 1:
+                time.sleep(3)
+                continue
+            resp.raise_for_status()
+            break
 
         program_dir.mkdir(parents=True, exist_ok=True)
         paw_path = program_dir / f"{program_id}.paw"
@@ -140,6 +147,17 @@ class PAWClient:
         resp.raise_for_status()
         return resp.json()
 
+    def list_programs(self, sort: str = "recent", per_page: int = 20, page: int = 1) -> dict:
+        """List programs for the authenticated user."""
+        resp = httpx.get(
+            f"{self._api_url}/api/v1/programs",
+            params={"mine": "true", "sort": sort, "per_page": per_page, "page": page},
+            headers=self._headers(),
+            timeout=10.0,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
 
 _default_client: PAWClient | None = None
 

{programasweights-0.2.1 → programasweights-0.2.2}/programasweights/runtime_llamacpp.py

@@ -53,12 +53,25 @@ class PawFunction:
         interpreter = self._meta.get("interpreter", "Qwen/Qwen3-0.6B")
         base_model_path = cache.get_base_model_path(interpreter)
 
-        self._llm = Llama(
-            model_path=str(base_model_path),
-            n_ctx=n_ctx,
-            n_gpu_layers=n_gpu_layers,
-            verbose=verbose,
-        )
+        if not verbose:
+            import os as _os, sys as _sys
+            _stderr_fd = _sys.stderr.fileno()
+            _devnull = _os.open(_os.devnull, _os.O_WRONLY)
+            _old_stderr = _os.dup(_stderr_fd)
+            _os.dup2(_devnull, _stderr_fd)
+
+        try:
+            self._llm = Llama(
+                model_path=str(base_model_path),
+                n_ctx=n_ctx,
+                n_gpu_layers=n_gpu_layers,
+                verbose=verbose,
+            )
+        finally:
+            if not verbose:
+                _os.dup2(_old_stderr, _stderr_fd)
+                _os.close(_devnull)
+                _os.close(_old_stderr)
 
         adapter_path = program_dir / "adapter.gguf"
         if adapter_path.exists():

{programasweights-0.2.1 → programasweights-0.2.2}/pyproject.toml

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

{programasweights-0.2.1 → programasweights-0.2.2}/server/api/routes/programs.py

@@ -292,6 +292,7 @@ async def list_programs(
             "compiler_snapshot": p.compiler_snapshot,
             "interpreter": p.interpreter,
             "author": author_map[p.author_id].username if p.author_id and p.author_id in author_map else "Anonymous",
+            "author_display_name": author_map[p.author_id].display_name if p.author_id and p.author_id in author_map else None,
             "author_avatar": author_map[p.author_id].avatar_url if p.author_id and p.author_id in author_map else None,
             "author_id": p.author_id,
             "tags": p.tags or [],
@@ -412,6 +413,15 @@ async def download_program(
     program.downloads = (program.downloads or 0) + 1
     await db.commit()
 
+    settings = get_settings()
+    local_paw = Path(settings.STORAGE_PATH) / program.id / f"{program.id}.paw"
+    if local_paw.exists():
+        return FileResponse(
+            path=str(local_paw),
+            media_type="application/octet-stream",
+            filename=f"{program.id}.paw",
+        )
+
     hf_url = f"https://huggingface.co/programasweights/paw-programs/resolve/main/{program.id}.paw"
     return RedirectResponse(url=hf_url, status_code=302)
 

{programasweights-0.2.1 → programasweights-0.2.2}/server/api/services/compile_provider.py

@@ -145,7 +145,7 @@ class CompileProvider:
         self.ref_tok = AutoTokenizer.from_pretrained(ref_model, trust_remote_code=True)
 
         self.compiler_fingerprint = self._compute_fingerprint()
-        self.pseudo_cache: dict[str, str] = {}
+        self._redis_url = os.environ.get("REDIS_URL", "redis://localhost:6379/0")
         self._compiler_model_name: str | None = None
 
         logger.info("compile_provider_ready",
@@ -216,9 +216,20 @@ class CompileProvider:
         cache_key = hashlib.sha256(
             f"{rendered}|max_tokens={max_tokens}|temp=0".encode()
         ).hexdigest()[:32]
-        if cache_key in self.pseudo_cache:
-            logger.info("pseudo_gen_cache_hit", spec_len=len(spec))
-            return self.pseudo_cache[cache_key], prompt_tokens
+
+        try:
+            import asyncpg
+            db_url = os.environ.get("DATABASE_URL", "postgresql://paw:pawdev2026@localhost:5432/paw")
+            conn = await asyncpg.connect(db_url)
+            row = await conn.fetchrow(
+                "SELECT pseudo_program FROM pseudo_cache WHERE cache_key = $1", cache_key
+            )
+            await conn.close()
+            if row:
+                logger.info("pseudo_gen_cache_hit", spec_len=len(spec))
+                return row["pseudo_program"], prompt_tokens
+        except Exception:
+            pass
 
         async with httpx.AsyncClient(timeout=60.0) as client:
             resp = await client.post(
@@ -233,7 +244,17 @@ class CompileProvider:
             resp.raise_for_status()
             data = resp.json()
             pseudo = data["choices"][0]["text"].strip()
-            self.pseudo_cache[cache_key] = pseudo
+
+            try:
+                conn = await asyncpg.connect(db_url)
+                await conn.execute(
+                    "INSERT INTO pseudo_cache (cache_key, pseudo_program) VALUES ($1, $2) ON CONFLICT (cache_key) DO NOTHING",
+                    cache_key, pseudo
+                )
+                await conn.close()
+            except Exception:
+                pass
+
             return pseudo, prompt_tokens
 
     def _build_compiler_input(self, spec: str, pseudo_program: str) -> str: