programasweights 0.4.1__tar.gz → 0.4.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programasweights
-Version: 0.4.1
+Version: 0.4.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

programasweights-0.4.2/README.md

@@ -0,0 +1,128 @@
+# ProgramAsWeights
+
+**Compile natural language specs into tiny neural functions that run locally.**
+
+Define what a function should do in plain English. PAW compiles it into a small neural program that runs on your machine — no API keys at runtime, no internet needed after setup, fully deterministic.
+
+## Install
+
+```bash
+pip install programasweights --extra-index-url https://pypi.programasweights.com/simple/
+```
+
+## Quick Start
+
+```python
+import programasweights as paw
+
+# Use a pre-compiled function (downloads once, runs locally forever)
+fn = paw.function("email-triage")
+fn("Urgent: the 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",
+    slug="json-fixer"              # optional: creates username/json-fixer handle
+)
+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"
+```
+
+If you specifically want the smaller browser-compatible runtime, pass `compiler="paw-4b-gpt2"`. Otherwise, omit `compiler` and let the server default decide.
+
+## Current Public 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                | 134 MB               |
+| Program size    | ~22 MB                | ~5 MB                |
+| Local inference | ~0.05-0.5s per call   | ~0.03-0.3s per call  |
+| Runs in browser | No                    | Yes (WebAssembly)    |
+
+The current server default is Standard (`paw-4b-qwen3-0.6b`). Use Compact (`paw-4b-gpt2`) when you need smaller files or browser deployment.
+
+If you need to inspect available compiler aliases programmatically, use `paw.list_compilers()`.
+
+GPU acceleration is enabled by default (Metal on Mac, CUDA on Linux, falls back to CPU). Set `PAW_GPU_LAYERS=0` to force CPU if GPU causes issues.
+
+## Browser SDK
+
+Programs compiled with GPT-2 also run in the browser via WebAssembly. The initial model and program assets download automatically; inference then runs client-side.
+
+```bash
+npm install @programasweights/web
+```
+
+```javascript
+import paw from '@programasweights/web';
+
+const fn = await paw.function('email-triage-browser');
+const result = await fn('Urgent: the server is down!');
+// result: "immediate"
+```
+
+If you load by program ID, browser inference only depends on Hugging Face-hosted assets. Slugs still need one PAW API lookup.
+
+New browser-compatible programs are uploaded to Hugging Face asynchronously after compile. They are usually ready within a minute or two, but under load can take a few minutes, so a freshly compiled browser program may need a short wait before the JS SDK can load it.
+
+See the [browser SDK repo](https://github.com/programasweights/programasweights-js) for full documentation.
+
+## Use with AI Agents
+
+PAW works with Cursor, Claude, Codex, and other AI coding assistants. Paste this into your agent's chat:
+
+> I want to use ProgramAsWeights (PAW) to create fuzzy text functions that run locally. Read the instructions at [https://programasweights.com/AGENTS.md](https://programasweights.com/AGENTS.md) and help me integrate it.
+
+Or save `[AGENTS.md](https://programasweights.com/agents)` to your project root — agents read it automatically.
+
+## 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
+
+## Authentication
+
+```bash
+# Option 1: environment variable (recommended)
+export PAW_API_KEY=paw_sk_...
+
+# Option 2: CLI login (opens browser to generate key)
+paw login
+```
+
+Generate API keys at [programasweights.com/settings](https://programasweights.com/settings). Authenticated users get higher rate limits.
+
+## CLI
+
+```bash
+paw compile --spec "Extract error lines from logs" --json
+paw run --program <program_id> --input "[ERROR] timeout" --json
+paw login
+```
+
+`--json` gives structured output for programmatic use.
+
+## Links
+
+- **Website**: [programasweights.com](https://programasweights.com)
+- **Documentation**: [programasweights.readthedocs.io](https://programasweights.readthedocs.io)
+- **Python SDK**: [github.com/programasweights/programasweights-python](https://github.com/programasweights/programasweights-python)
+- **Browser SDK**: [github.com/programasweights/programasweights-js](https://github.com/programasweights/programasweights-js)
+- **Program Hub**: [programasweights.com/hub](https://programasweights.com/hub)
+
+## License
+
+MIT

{programasweights-0.4.1 → programasweights-0.4.2}/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.1"
+    __version__ = "0.4.2"
 
 from .config import get_api_url, get_api_key, set_api_key
 

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "programasweights"
-version = "0.4.1"
+version = "0.4.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.4.1/README.md

@@ -1,186 +0,0 @@
-# ProgramAsWeights
-
-Programs as small weight blobs; a fixed interpreter runs them.
-
-## Development
-
-```
-pip install -e .
-```
-
-```
-python test_compile.py
-```
-
-```
-python test_execute.py
-```
-
-
-## Quickstart
-
-```bash
-pip install programasweights
-```
-
-```python
-import programasweights
-f = programasweights.function("/path/to/weights")
-print(f("Hello"))
-```
-
-- weights = programs; base model = interpreter.
-- Deterministic by default (greedy generation).
-
-## 🌐 Web Interface
-
-ProgramAsWeights includes a modern web interface for easy interaction with the system. The web app provides a user-friendly way to compile specifications, test neural programs, and manage models without writing code.
-
-### Features
-
-- **Interactive Model Selection**: Choose from available compiler and interpreter models
-- **Natural Language Specifications**: Describe your program in plain English
-- **GPT-Powered Examples**: Auto-generate test data using OpenAI's API
-- **Real-time Compilation**: Compile specs into neural programs instantly
-- **Interactive Testing**: Test compiled programs with custom inputs
-- **Model Downloads**: Download compiled models as `.tgz` files
-- **Community Sharing**: Publish and discover programs on the leaderboard
-
-### Quick Start
-
-1. **Prerequisites**: Ensure you have Python 3.8+, Node.js 16+, and npm installed
-
-2. **Start the application**:
-   ```bash
-   cd web-app
-   ./start.sh
-   ```
-
-3. **Access the interface**:
-   - **Web App**: http://localhost:5173
-   - **API Docs**: http://localhost:8000/docs
-
-The startup script automatically:
-- Installs Python and Node.js dependencies
-- Starts the FastAPI backend server
-- Starts the React frontend development server
-
-### Manual Setup (Alternative)
-
-If you prefer manual setup:
-
-```bash
-# Backend
-cd web-app/backend
-pip install -r requirements.txt
-python run_server.py
-
-# Frontend (in another terminal)
-cd web-app/frontend  
-npm install
-npm run dev
-```
-
-### Configuration
-
-Create `web-app/backend/.env` with:
-```bash
-OPENAI_API_KEY=your_openai_api_key_here  # Optional: for GPT test generation
-CHECKPOINT_DIR=../../outputs_1spec/prefix_kv  # Path to trained models
-```
-
-### Example Workflow
-
-1. Select "Qwen 2.5 Coder 0.5B" as compiler and "PAW Interpreter" as interpreter
-2. Enter specification: *"Parse a string like '(A) cat (B) dog' into a JSON list"*
-3. Generate examples with GPT or add manually
-4. Click "Compile" to create your neural program
-5. Test with input: *"(A) red apple (B) green banana"*
-6. Download or publish your compiled model
-
-For detailed documentation, see [`web-app/README.md`](web-app/README.md).
-
-## Train a compiler→KV prefix→interpreter (defaults)
-
-```bash
-# installs training extras
-pip install -e .[train]
-
-# trains on data/samples_train.jsonl with Qwen defaults
-paw-train
-```
-
-- Produces checkpoint under `outputs/prefix_kv/checkpoint/`.
-
-## Compile then run (qualitative eval)
-
-```bash
-# compile a prompt into a KV-prefix artifact
-paw-eval
-```
-
-Or programmatically:
-
-```python
-import programasweights as paw
-
-prompt = (
-    "Parse a string like '(A) ... (B) ... (C) ...' into a JSON list of options. "
-    "Be robust to noise: extra spaces, bullets, and phrases like 'both (A) and (B)'."
-)
-
-artifact_dir = paw.compile(
-    out_dir="outputs/prefix_kv/demo_program",
-    spec=prompt,
-    checkpoint_dir="outputs/prefix_kv/checkpoint",
-)
-
-f = paw.function(artifact_dir, interpreter_name="Qwen/Qwen2.5-Coder-0.5B-Instruct", max_new_tokens=128)
-print(f("(A) cat  (B) dog  (C) both (A) and (B) are possible"))
-```
-
-- The dummy compiler is still available as `compile_dummy` for tests and demos.
-
-## API
-
-```python
-import programasweights
-parse_func = programasweights.function(
-    "/path/to/weights.safetensors",
-    interpreter_name="google/flan-t5-small",
-    max_new_tokens=128,
-)
-output = parse_func("input string")
-```
-
-- Accepts `str` or `List[str]` and returns the same shape.
-- Aliasing works: `import programasweights as paw`.
-
-## Local development
-
-```bash
-pip install -e .[test]
-pytest -q
-```
-
-```bash
-# smoke check
-python -c "import programasweights as paw; print(paw.__version__)"
-```
-
-- `pip install -e .` installs in editable mode so code changes are picked up without reinstalling.
-- If you do not need editable mode: `pip install .` (you must reinstall after changes).
-
-## Notes
-
-- MVP runtime uses a single in-process interpreter (loads the base model once and stays warm).
-- Program artifact can be a prompt/prefix (text file) or a KV-prefix directory with `program.json` and `kv_prefix.pt`.
-- Device selection: CUDA if available, else CPU. Override with env var `PROGRAMASWEIGHTS_DEVICE`.
-- Simple global lock around `generate()` for thread safety.
-
-## Roadmap
-
-- Compiler: spec → weights
-- LoRA support
-- JSON-constrained decoding
-- Server mode (multi-tenant)