programasweights 0.2.0__tar.gz → 0.2.2.dev1__tar.gz

programasweights-0.2.2.dev1/.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.0 → programasweights-0.2.2.dev1}/.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.0 → programasweights-0.2.2.dev1}/AGENTS.md

@@ -24,10 +24,9 @@ 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
-    slug="json-fixer"              # optional: creates da03/json-fixer handle
+    compiler="paw-4b-qwen3-0.6b"  # or "paw-4b-gpt2" for smaller/faster
 )
-fn = paw.function(program.slug)    # or paw.function(program.id)
+fn = paw.function(program.id)
 fn("{name: 'Alice',}")  # '{"name": "Alice"}'
 ```
 
@@ -72,38 +71,41 @@ Use this when you want to offload all computation to the user's browser: zero se
 - **Intent routing** — map user descriptions to the closest URL, menu item, or setting
 - **Agent preprocessing** — parse tool calls, validate outputs, route tasks
 
-## Authentication
+## Authentication (optional)
+
+Everything works without authentication. Sign in for higher rate limits and program naming.
 
 ```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 https://programasweights.com/settings
+Generate API keys at https://programasweights.com/settings. The SDK reads `PAW_API_KEY` from the environment automatically.
 
-The SDK automatically reads `PAW_API_KEY` from the environment. Authenticated users get higher rate limits (60 compiles/hr vs 5 for anonymous).
+| | Anonymous | Authenticated |
+|---|---|---|
+| Compile rate limit | 20/hr | 60/hr |
+| Name programs (slugs) | No | Yes |
 
 ## Program Naming
 
-Programs have an immutable hash ID (e.g. `a6b454023d41ac9ca845`). Authenticated
-users can optionally assign a slug at compile time to create a human-readable
-handle like `da03/json-fixer`. Both forms work everywhere:
+Every compiled program gets an immutable hash ID (e.g. `a6b454023d41ac9ca845`). Authenticated users can also assign a human-readable slug:
 
 ```python
-fn = paw.function("da03/json-fixer")     # by slug
-fn = paw.function("a6b454023d41ac9ca845") # by hash
+program = paw.compile("Classify sentiment", slug="my-classifier")
+# program.id   -> "a6b454023d41ac9ca845"
+# program.slug -> "da03/my-classifier"
+
+fn = paw.function("da03/my-classifier")  # by slug (requires auth to create)
+fn = paw.function("a6b454023d41ac9ca845") # by hash (always works)
 ```
 
 ## CLI
 
 ```bash
-paw compile --spec "Classify sentiment" --slug "my-classifier" --json
-paw run --program "da03/my-classifier" --input "I love this!" --json
-paw rename <program> <new-slug>   # rename a program's slug
-paw info <program>                # show program metadata
+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
 ```
 
@@ -112,9 +114,9 @@ paw login                         # save API key
 ## API
 
 ```python
-paw.compile(spec, slug="my-fn")   # Compile with optional slug
-paw.function(name_or_id)          # Load by slug or hash
-paw.login()                       # Save API key
+paw.compile(spec)                 # compile (returns Program with .id)
+paw.function(program_id_or_slug)  # load for local inference
+paw.login()                       # save API key
 ```
 
 ## Browse Programs

{programasweights-0.2.0 → programasweights-0.2.2.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programasweights
-Version: 0.2.0
+Version: 0.2.2.dev1
 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.2.2.dev1/docs/api-reference/cli.md

@@ -0,0 +1,90 @@
+# CLI Reference
+
+The `paw` command-line interface mirrors the Python SDK. Install from PyPI; the entry point is `paw`.
+
+```bash
+pip install programasweights --extra-index-url https://pypi.programasweights.com/simple/
+```
+
+## Global options
+
+| Option | Description |
+|--------|-------------|
+| `--api-url` | Override the API base URL (default: `https://programasweights.com`). |
+| `--api-key` | API key for authenticated requests. Also reads `PAW_API_KEY` env var. |
+| `--json` | Machine-readable JSON output (supported by all subcommands). |
+
+## `paw compile`
+
+Compile a natural-language specification on the server.
+
+```bash
+paw compile --spec "Classify message urgency" [--compiler paw-4b-qwen3-0.6b] [--slug my-classifier] [--json]
+```
+
+| Option | Description |
+|--------|-------------|
+| `--spec` | Specification text to compile (required). |
+| `--compiler` | Compiler model (default: `paw-4b-qwen3-0.6b`). |
+| `--slug` | URL-safe handle (e.g. `my-classifier`). Creates a `username/slug` alias. Requires auth. |
+| `--json` | JSON output with `program_id`, `slug`, `status`, `timings`. |
+
+## `paw run`
+
+Run inference locally against a compiled program.
+
+```bash
+paw run --program <id_or_slug> --input "your text" [--max-tokens 512] [--temperature 0.0] [--json]
+```
+
+| Option | Description |
+|--------|-------------|
+| `--program` | Program hash ID, slug (e.g. `da03/my-classifier`), or official name (e.g. `email-triage`). |
+| `--input` | Input text for the program. |
+| `--max-tokens` | Maximum tokens to generate (default: 512). |
+| `--temperature` | Sampling temperature (default: 0.0). |
+| `--verbose` | Print llama.cpp debug output. |
+| `--json` | JSON output with `program`, `input`, `output`. |
+
+## `paw rename`
+
+Set or change a program's slug handle. Requires authentication.
+
+```bash
+paw rename <program_id> <new-slug> [--json]
+```
+
+| Argument | Description |
+|----------|-------------|
+| `program_id` | Program hash ID or current slug. |
+| `new-slug` | New slug name (2-50 chars, lowercase alphanumeric and hyphens). |
+
+## `paw info`
+
+Show metadata for a program.
+
+```bash
+paw info <program_id_or_slug> [--json]
+```
+
+## `paw login`
+
+Save an API key for authenticated requests.
+
+```bash
+paw login [key]
+```
+
+If `key` is provided, saves it directly. If omitted, opens the browser to generate one at `programasweights.com/settings`.
+
+## Agent workflow example
+
+```bash
+PROGRAM_ID=$(paw compile --spec "Classify urgency" --json | jq -r '.program_id')
+paw run --program "$PROGRAM_ID" --input "Please review by EOD" --json
+```
+
+## Related
+
+- [Python SDK Reference](python-sdk.md)
+- [REST API Reference](rest-api.md)

programasweights-0.2.2.dev1/docs/api-reference/python-sdk.md

@@ -0,0 +1,107 @@
+# Python SDK Reference
+
+The `programasweights` package compiles natural language specs into neural programs that run locally.
+
+## Install
+
+```bash
+pip install programasweights --extra-index-url https://pypi.programasweights.com/simple/
+```
+
+## Import
+
+```python
+import programasweights as paw
+```
+
+## `paw.function`
+
+```python
+fn = paw.function(name_or_id, n_ctx=2048, n_gpu_layers=0, verbose=False)
+```
+
+Loads a compiled program and returns a callable. Downloads the program and base model on first use; cached locally after that. Works offline after first download.
+
+| Parameter | Description |
+|-----------|-------------|
+| `name_or_id` | Program 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`). |
+
+The returned callable:
+
+```python
+output: str = fn(input_text, max_tokens=512, temperature=0.0)
+```
+
+| Parameter | Description |
+|-----------|-------------|
+| `input_text` | Input string for the program. |
+| `max_tokens` | Maximum tokens to generate (default `512`). |
+| `temperature` | Sampling temperature (default `0.0`). |
+
+## `paw.compile`
+
+```python
+program = paw.compile(
+    spec,
+    compiler="paw-4b-qwen3-0.6b",
+    name=None,
+    tags=None,
+    public=True,
+    slug=None,
+)
+```
+
+Compiles a natural language spec on the server. Returns a `Program` object.
+
+| Parameter | Description |
+|-----------|-------------|
+| `spec` | Natural language specification (10-8000 chars). |
+| `compiler` | Compiler name: `paw-4b-qwen3-0.6b` (Standard) or `paw-4b-gpt2` (Compact). |
+| `name` | Display title for the hub (auto-generated if omitted). |
+| `tags` | Tags for discovery (list of strings, max 10). |
+| `public` | Whether to list on the public hub (default `True`). |
+| `slug` | URL-safe handle (e.g. `my-classifier`). Creates a `username/slug` alias. Requires authentication. |
+
+**Return value** -- `Program` object:
+
+| Attribute | Description |
+|-----------|-------------|
+| `id` | Hash-based program identifier. Use with `paw.function(program.id)`. |
+| `slug` | Full slug handle (e.g. `da03/my-classifier`) if one was created, `None` otherwise. |
+| `status` | `"ready"` on success, `"failed"` on error. |
+| `compiler_snapshot` | Exact compiler version used. |
+| `timings` | Timing metadata from the server. |
+| `error` | Error message when compilation fails. |
+
+## `paw.login`
+
+```python
+paw.login(key=None)
+```
+
+Saves an API key for authenticated requests. If `key` is provided, saves it directly. If omitted, opens the browser to generate a key at `programasweights.com/settings`.
+
+Keys are stored in `~/.config/programasweights/config.json` and loaded automatically on subsequent imports.
+
+You can also set the `PAW_API_KEY` environment variable instead:
+
+```bash
+export PAW_API_KEY=paw_sk_...
+```
+
+## Configuration
+
+| 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.__version__` | Installed package version string. |
+
+## Related
+
+- [CLI Reference](cli.md)
+- [REST API Reference](rest-api.md)
+- [Naming Programs](../getting-started/naming-programs.md)

{programasweights-0.2.0 → programasweights-0.2.2.dev1}/docs/api-reference/rest-api.md

@@ -69,39 +69,50 @@ List or search programs.
 
 ### `GET /programs/{id_or_slug}`
 
-Program detail including aliases, specification, and pseudo-program where exposed by policy.
+Program detail. Accepts hash ID or slug. Private programs return 404 to non-owners.
 
-### `GET /programs/{id}/download`
+**Response** includes: `id`, `name`, `spec`, `interpreter`, `public`, `aliases`, `user_slug`, `author`, `tags`, `upvotes`, `downloads`, `created_at`.
 
-Redirects to the Hugging Face CDN for the `.paw` artifact download.
+### `PATCH /programs/{id_or_slug}`
+
+Update program metadata. **Authentication required.**
+
+Owner-only fields: `public`, `name`, `tags`. Any authenticated user can set their own `slug`.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `public` | boolean | Visibility (owner only). |
+| `name` | string | Display title, max 100 chars (owner only). |
+| `tags` | string[] | Tags, max 5 items (owner only). |
+| `slug` | string | URL-safe handle, 2-50 chars, `^[a-z0-9][a-z0-9-]*[a-z0-9]$`. Creates/replaces your alias for this program. |
+
+### `GET /programs/{id_or_slug}/download`
+
+Redirects to the Hugging Face CDN for the `.paw` artifact. Private programs return 404 to non-owners.
 
 ### `GET /programs/resolve/{slug}`
 
-Resolve a slug or alias to a canonical `program_id`.
+Resolve a slug (e.g. `da03/my-classifier` or bare `email-triage`) to a canonical `program_id`.
 
 ### `POST /programs/{id}/alias`
 
-Create an alias for the program. **Authentication required.**
-
-**Request body (JSON):**
+Create or update your alias for a program. **Authentication required.** If you already have an alias for this program, it is replaced (atomic update).
 
 | Field | Type | Description |
 |-------|------|-------------|
-| `slug` | string | Alias slug to register. |
+| `slug` | string | Slug name, 2-50 chars, lowercase alphanumeric and hyphens. |
 
-### `POST /programs/{id}/vote`
+### `POST /programs/{id_or_slug}/vote`
 
-Submit a vote for a program. **Authentication required.**
-
-**Request body (JSON):**
+Submit a vote. **Authentication required.**
 
 | Field | Type | Description |
 |-------|------|-------------|
-| `vote` | integer | `1` (up) or `-1` (down). |
+| `vote` | integer | `1` (upvote) or `-1` (downvote). Same value again removes the vote. |
 
 ### `GET /programs/{id}/cases` and `POST /programs/{id}/cases`
 
-Community feedback and case submission for a program. Method-specific payloads follow the server schema for each verb.
+Community case submission for a program.
 
 ### `GET /auth/github`
 

{programasweights-0.2.0 → programasweights-0.2.2.dev1}/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.0"
+__version__ = "0.2.2.dev1"
 
 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.0 → programasweights-0.2.2.dev1}/programasweights/cli.py

@@ -27,7 +27,8 @@ def cmd_compile(args):
     if not args.json:
         print(f"Compiling: {args.spec[:80]}...")
 
-    program = paw.compile(args.spec, compiler=args.compiler, slug=getattr(args, 'slug', None))
+    public = not getattr(args, 'private', False)
+    program = paw.compile(args.spec, compiler=args.compiler, slug=getattr(args, 'slug', None), public=public)
 
     if args.json:
         print(json.dumps({
@@ -170,6 +171,7 @@ def main():
     p.add_argument("--spec", required=True, help="Natural language specification")
     p.add_argument("--compiler", default="paw-4b-qwen3-0.6b", help="Compiler model")
     p.add_argument("--slug", default=None, help="URL-safe handle (e.g. 'message-classifier')")
+    p.add_argument("--private", action="store_true", help="Make program private (not listed on hub)")
     p.add_argument("--json", action="store_true", help="JSON output")
 
     p = sub.add_parser("run", help="Run a program locally via llama.cpp")

{programasweights-0.2.0 → programasweights-0.2.2.dev1}/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.0 → programasweights-0.2.2.dev1}/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.0 → programasweights-0.2.2.dev1}/pyproject.toml

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