programasweights 0.2.2.dev1__tar.gz → 0.2.4__tar.gz

programasweights-0.2.4/AGENTS.md

@@ -0,0 +1,173 @@
+# 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 it 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 for 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
+
+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
+""")
+```
+
+- State output constraints explicitly if any: "Return ONLY one of: X, Y, Z"
+- Each function is stateless: one input, one output. No conversation history.
+- Write a few test inputs with expected outputs, then try different spec phrasings and pick the one that passes the most.
+
+## Browser / JavaScript SDK
+
+Programs compiled with `paw-4b-gpt2` run 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)
+
+Sign in for higher rate limits and program naming. Everything works without it.
+
+```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", "error": null, "timings": {"total_ms": 2800}}
+```
+
+## Full API Reference
+
+```python
+program = paw.compile(
+    spec,                               # natural language specification (str)
+    compiler="paw-4b-qwen3-0.6b",
+    slug=None,                          # URL-safe handle (requires auth)
+    public=True,                        # list on public hub
+)
+# Returns: Program(id, slug, status, timings, error)
+
+fn = paw.function(program)              # accepts Program object, hash ID, or slug
+fn = paw.function("a6b454023d41ac9ca845")
+fn = paw.function("da03/my-classifier")
+
+result: str = fn(input_text: str, max_tokens=512, temperature=0.0)
+
+fn = paw.compile_and_load(spec, compiler="paw-4b-qwen3-0.6b")
+
+programs = paw.list_programs(sort="recent", per_page=20)  # requires auth
+
+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) | Adjust spec length. |
+| `httpx.HTTPStatusError: 429` | Rate limit exceeded | Wait, or sign in for higher limits. |
+
+## Performance
+
+- **First call** ~500ms (loads base model). Subsequent calls ~50-90ms.
+- **Base model shared** across functions. Each LoRA adapter adds ~22 MB.
+- **Thread-safe** and **blocking**.
+- **Cache**: `~/.cache/programasweights/`. Override with `PAW_CACHE_DIR`.
+- **Offline** after first download.
+
+## Browse Programs
+
+https://programasweights.com/hub

{programasweights-0.2.2.dev1 → programasweights-0.2.4}/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.2.dev1 → programasweights-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programasweights
-Version: 0.2.2.dev1
+Version: 0.2.4
 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.2.dev1 → programasweights-0.2.4}/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.2.dev1 → programasweights-0.2.4}/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.2.dev1 → programasweights-0.2.4}/programasweights/__init__.py

@@ -21,8 +21,9 @@ API reference:
     paw.api_url                Server URL (default: https://programasweights.com)
     paw.api_key                API key (set via login() or PAW_API_KEY env var)
 """
+from __future__ import annotations
 
-__version__ = "0.2.2.dev1"
+__version__ = "0.2.4"
 
 from .config import get_api_url, get_api_key, set_api_key
 

{programasweights-0.2.2.dev1 → programasweights-0.2.4}/programasweights/client.py

@@ -108,25 +108,38 @@ 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.
+        Handles 202 Accepted (assets still generating) and 302 redirects (HF CDN).
         """
         program_dir = config.get_programs_dir() / program_id
         if (program_dir / "prompt_template.txt").exists():
             return program_dir
 
-        max_retries = 10
-        for attempt in range(max_retries):
+        max_wait = 30
+        elapsed = 0
+        resp = None
+        while elapsed < max_wait:
             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:
+            if resp.status_code == 202:
+                retry_after = int(resp.headers.get("Retry-After", "3"))
+                time.sleep(retry_after)
+                elapsed += retry_after
+                continue
+            if resp.status_code == 404 and elapsed < max_wait - 3:
                 time.sleep(3)
+                elapsed += 3
                 continue
             resp.raise_for_status()
             break
+        else:
+            raise RuntimeError(
+                f"Program {program_id} assets not ready after {max_wait}s. "
+                "The program may still be generating. Try again shortly."
+            )
 
         program_dir.mkdir(parents=True, exist_ok=True)
         paw_path = program_dir / f"{program_id}.paw"

{programasweights-0.2.2.dev1 → programasweights-0.2.4}/programasweights/runtime_llamacpp.py

@@ -67,24 +67,24 @@ class PawFunction:
                 n_gpu_layers=n_gpu_layers,
                 verbose=verbose,
             )
+
+            adapter_path = program_dir / "adapter.gguf"
+            if adapter_path.exists():
+                self._adapter = llama_cpp.llama_adapter_lora_init(
+                    self._llm.model, str(adapter_path).encode("utf-8"),
+                )
+                if self._adapter:
+                    llama_cpp.llama_set_adapter_lora(self._llm.ctx, self._adapter, 1.0)
+                else:
+                    raise RuntimeError(f"Failed to load LoRA adapter: {adapter_path}")
+            else:
+                self._adapter = None
         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():
-            self._adapter = llama_cpp.llama_adapter_lora_init(
-                self._llm.model, str(adapter_path).encode("utf-8"),
-            )
-            if self._adapter:
-                llama_cpp.llama_set_adapter_lora(self._llm.ctx, self._adapter, 1.0)
-            else:
-                raise RuntimeError(f"Failed to load LoRA adapter: {adapter_path}")
-        else:
-            self._adapter = None
-
         placeholder = "{INPUT_PLACEHOLDER}"
         self._use_special = interpreter not in ("gpt2",)
 

{programasweights-0.2.2.dev1 → programasweights-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "programasweights"
-version = "0.2.2.dev1"
+version = "0.2.4"
 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.2.dev1 → programasweights-0.2.4}/server/.env.example

@@ -44,4 +44,3 @@ LOG_FORMAT=json
 # Server
 HOST=0.0.0.0
 PORT=8000
-WORKERS=4

{programasweights-0.2.2.dev1 → programasweights-0.2.4}/server/api/config.py

@@ -50,10 +50,9 @@ class Settings(BaseSettings):
     LOG_LEVEL: str = "INFO"
     LOG_FORMAT: str = "json"
 
-    # Server
+    # Server (single process: sessions and compile jobs are in-memory)
     HOST: str = "0.0.0.0"
     PORT: int = 8000
-    WORKERS: int = 4
 
     # CORS
     CORS_ORIGINS: list[str] = [

{programasweights-0.2.2.dev1 → programasweights-0.2.4}/server/api/main.py

@@ -16,6 +16,8 @@ from redis.asyncio import Redis
 
 from api.config import get_settings
 from api.logging_config import configure_logging, request_id_ctx
+from collections import deque
+
 from api.middleware.rate_limit import (
     RateLimiter,
     identifier_for_request,
@@ -29,6 +31,31 @@ gpu_semaphore = asyncio.Semaphore(1)
 
 _RATE_LIMITED_PATHS = {"/api/v1/compile", "/api/v1/infer", "/api/v1/feedback"}
 
+_FALLBACK_LIMITS = {"compile": 13000, "infer": 5700}
+_FALLBACK_WINDOW = 3600
+
+
+class _FallbackLimiter:
+    """In-memory global rate limiter used when Redis is unavailable."""
+
+    def __init__(self):
+        self._windows: dict[str, deque] = {
+            "compile": deque(),
+            "infer": deque(),
+        }
+
+    def check(self, endpoint: str) -> bool:
+        key = "compile" if "compile" in endpoint else "infer"
+        now = time.time()
+        window = self._windows[key]
+        cutoff = now - _FALLBACK_WINDOW
+        while window and window[0] < cutoff:
+            window.popleft()
+        if len(window) >= _FALLBACK_LIMITS[key]:
+            return False
+        window.append(now)
+        return True
+
 
 def create_app() -> FastAPI:
     settings = get_settings()
@@ -45,13 +72,13 @@ def create_app() -> FastAPI:
         openapi_url="/api/openapi.json",
     )
 
-    # Redis + rate limiter (attached to app state for access in routes)
     redis_client: Redis | None = None
     rate_limiter: RateLimiter | None = None
+    fallback_limiter: _FallbackLimiter | None = None
 
     @app.on_event("startup")
     async def startup_redis():
-        nonlocal redis_client, rate_limiter
+        nonlocal redis_client, rate_limiter, fallback_limiter
         try:
             redis_client = Redis.from_url(
                 settings.REDIS_URL, decode_responses=True, socket_connect_timeout=5,
@@ -60,11 +87,14 @@ def create_app() -> FastAPI:
             rate_limiter = RateLimiter(redis_client)
             app.state.redis = redis_client
             app.state.rate_limiter = rate_limiter
+            app.state.redis_available = True
             logger.info("redis_connected", url=settings.REDIS_URL)
         except Exception:
-            logger.warning("redis_unavailable", url=settings.REDIS_URL)
+            logger.warning("redis_unavailable, using in-memory global fallback limiter", url=settings.REDIS_URL)
             app.state.redis = None
             app.state.rate_limiter = None
+            app.state.redis_available = False
+            fallback_limiter = _FallbackLimiter()
 
     @app.on_event("shutdown")
     async def shutdown_redis():
@@ -90,7 +120,23 @@ def create_app() -> FastAPI:
         token = request_id_ctx.set(rid)
         try:
             # Rate limiting for /compile and /infer
-            if request.method == "POST" and request.url.path in _RATE_LIMITED_PATHS and rate_limiter is not None:
+            if request.method == "POST" and request.url.path in _RATE_LIMITED_PATHS and rate_limiter is None and fallback_limiter is not None:
+                endpoint = "compile" if "compile" in request.url.path else "infer"
+                if not fallback_limiter.check(endpoint):
+                    logger.info("fallback_rate_limited", endpoint=endpoint)
+                    return JSONResponse(
+                        status_code=429,
+                        content={
+                            "error": "rate_limit_exceeded",
+                            "message": "Server is busy. Please try again shortly.",
+                            "request_id": rid,
+                        },
+                        headers={"Retry-After": "10"},
+                    )
+                request.state.has_concurrent_lock = False
+                request.state.rate_limit_result = None
+
+            elif request.method == "POST" and request.url.path in _RATE_LIMITED_PATHS and rate_limiter is not None:
                 from api.dependencies import get_current_user
                 from api.models.database import get_db
 

{programasweights-0.2.2.dev1 → programasweights-0.2.4}/server/api/models/schemas.py

@@ -213,6 +213,7 @@ class HealthResponse(BaseModel):
     gpu_services: dict
     queue_depth: int
     uptime_s: float
+    warnings: list[str] = []
 
 
 # --- Error ---

{programasweights-0.2.2.dev1 → programasweights-0.2.4}/server/api/routes/auth.py

@@ -132,7 +132,6 @@ async def github_callback(code: str, state: str, request: Request, db: AsyncSess
         "email": email,
         "avatar_url": avatar_url,
         "tier": "github",
-        "github_access_token": access_token,
         "created_at": time.time(),
     }
     _sessions[session_token] = user_info

{programasweights-0.2.2.dev1 → programasweights-0.2.4}/server/api/routes/compile.py

@@ -140,7 +140,7 @@ async def submit_compile(
                 public=req.public,
                 name=req.name,
                 tags=req.tags,
-                hf_url=f"https://huggingface.co/programasweights/paw-programs/resolve/main/{pid}.paw",
+                hf_url=None,
             ))
 
         db.add(CompileLog(

{programasweights-0.2.2.dev1 → programasweights-0.2.4}/server/api/routes/health.py

@@ -4,7 +4,7 @@ Health check endpoint.
 
 import time
 
-from fastapi import APIRouter
+from fastapi import APIRouter, Request
 
 from api.models.schemas import HealthResponse
 
@@ -14,11 +14,16 @@ _start_time = time.time()
 
 
 @router.get("/health", response_model=HealthResponse)
-async def health_check():
+async def health_check(request: Request):
+    warnings = []
+    if not getattr(request.app.state, "redis_available", True):
+        warnings.append("redis_unavailable: using in-memory global rate limit fallback")
+
     return HealthResponse(
-        status="healthy",
+        status="healthy" if not warnings else "degraded",
         version="0.2.0",
         gpu_services={},
         queue_depth=0,
         uptime_s=time.time() - _start_time,
+        warnings=warnings,
     )

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

@@ -6,7 +6,7 @@ import re
 from pathlib import Path
 
 from fastapi import APIRouter, Depends, HTTPException, Request
-from fastapi.responses import FileResponse, RedirectResponse
+from fastapi.responses import FileResponse, JSONResponse, RedirectResponse
 
 from api.config import get_settings
 from sqlalchemy import func, select, or_
@@ -146,9 +146,10 @@ async def list_programs(
     if search_term:
         try:
             from redis.asyncio import Redis as AsyncRedis
-            redis = AsyncRedis.from_url("redis://localhost:6379/0", decode_responses=True, socket_connect_timeout=1)
-            queue_depth = int(await redis.get("paw:compile_queue_depth") or 0)
-            await redis.aclose()
+            settings = get_settings()
+            _redis = AsyncRedis.from_url(settings.REDIS_URL, decode_responses=True, socket_connect_timeout=1)
+            queue_depth = int(await _redis.get("paw:compile_queue_depth") or 0)
+            await _redis.aclose()
             server_idle = queue_depth <= 1
         except Exception:
             server_idle = True
@@ -413,6 +414,10 @@ async def download_program(
     program.downloads = (program.downloads or 0) + 1
     await db.commit()
 
+    if program.hf_url:
+        hf_url = f"https://huggingface.co/programasweights/paw-programs/resolve/main/{program.id}.paw"
+        return RedirectResponse(url=hf_url, status_code=302)
+
     settings = get_settings()
     local_paw = Path(settings.STORAGE_PATH) / program.id / f"{program.id}.paw"
     if local_paw.exists():
@@ -422,8 +427,11 @@ async def download_program(
             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)
+    return JSONResponse(
+        status_code=202,
+        content={"status": "generating", "message": "Program assets are being prepared. Retry shortly."},
+        headers={"Retry-After": "3"},
+    )
 
 
 ALLOWED_ASSETS = {"adapter.gguf", "prompt_template.txt", "prefix_cache.bin", "prefix_tokens.json"}
@@ -442,18 +450,25 @@ async def serve_program_asset(
     if not program:
         raise HTTPException(status_code=404, detail="Asset not found")
 
+    if program.hf_url:
+        hf_url = f"https://huggingface.co/programasweights/paw-programs/resolve/main/{program.id}/{filename}"
+        return RedirectResponse(url=hf_url, status_code=302)
+
     settings = get_settings()
     asset_path = Path(settings.STORAGE_PATH) / program.id / filename
-    if not asset_path.exists():
-        raise HTTPException(status_code=404, detail="Asset not found on this server")
-
-    media_type = "application/octet-stream"
-    if filename.endswith(".txt"):
-        media_type = "text/plain"
-    elif filename.endswith(".json"):
-        media_type = "application/json"
-
-    return FileResponse(path=str(asset_path), media_type=media_type, filename=filename)
+    if asset_path.exists():
+        media_type = "application/octet-stream"
+        if filename.endswith(".txt"):
+            media_type = "text/plain"
+        elif filename.endswith(".json"):
+            media_type = "application/json"
+        return FileResponse(path=str(asset_path), media_type=media_type, filename=filename)
+
+    return JSONResponse(
+        status_code=202,
+        content={"status": "generating", "message": "Program assets are being prepared. Retry shortly."},
+        headers={"Retry-After": "3"},
+    )
 
 
 # --- Update program ---

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

@@ -509,10 +509,22 @@ class CompileProvider:
                     upload_all_to_hf, program_id, adapter_dir,
                     self.interpreter, paw_path,
                 )
-                logger.info("hf_upload_done", program_id=program_id, hf_url=hf_url)
 
-                await asyncio.sleep(300)
-                cleanup_after_upload(adapter_dir, program_id)
+                if hf_url:
+                    from api.models.database import get_engine
+                    from sqlalchemy import text as sa_text
+                    engine = get_engine()
+                    with engine.connect() as conn:
+                        conn.execute(
+                            sa_text("UPDATE programs SET hf_url = :url WHERE id = :pid"),
+                            {"url": hf_url, "pid": program_id},
+                        )
+                        conn.commit()
+                    logger.info("hf_upload_done", program_id=program_id, hf_url=hf_url)
+                    await asyncio.sleep(300)
+                    cleanup_after_upload(adapter_dir, program_id)
+                else:
+                    logger.warning("hf_upload_failed_keeping_local", program_id=program_id)
             except Exception:
                 logger.exception("background_failed", program_id=program_id)