programasweights 0.1.0.dev8__tar.gz → 0.1.0.dev10__tar.gz

{programasweights-0.1.0.dev8 → programasweights-0.1.0.dev10}/AGENTS.md

@@ -8,7 +8,7 @@ Docs: https://programasweights.readthedocs.io
 ## Install
 
 ```bash
-pip install --pre programasweights
+pip install --pre programasweights --extra-index-url https://pypi.programasweights.com/simple/
 ```
 
 ## Usage

{programasweights-0.1.0.dev8 → programasweights-0.1.0.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programasweights
-Version: 0.1.0.dev8
+Version: 0.1.0.dev10
 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
@@ -22,7 +22,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
 Requires-Dist: httpx<1.0,>=0.27.0
-Requires-Dist: llama-cpp-python<1.0,>=0.3.0
+Requires-Dist: llama-cpp-python<=0.3.18,>=0.3.0
 Provides-Extra: test
 Requires-Dist: pytest; extra == 'test'
 Description-Content-Type: text/markdown
@@ -36,7 +36,7 @@ Define what a function should do in plain English. PAW compiles it into a small
 ## Install
 
 ```bash
-pip install programasweights
+pip install programasweights --extra-index-url https://pypi.programasweights.com/simple/
 ```
 
 ## Quick Start

{programasweights-0.1.0.dev8 → programasweights-0.1.0.dev10}/PYPI_README.md

@@ -7,7 +7,7 @@ Define what a function should do in plain English. PAW compiles it into a small
 ## Install
 
 ```bash
-pip install programasweights
+pip install programasweights --extra-index-url https://pypi.programasweights.com/simple/
 ```
 
 ## Quick Start

{programasweights-0.1.0.dev8 → programasweights-0.1.0.dev10}/docs/getting-started/installation.md

@@ -3,23 +3,21 @@
 Install the ProgramAsWeights SDK from PyPI:
 
 ```bash
-pip install --pre programasweights
+pip install --pre programasweights --extra-index-url https://pypi.programasweights.com/simple/
 ```
 
-## Requirements
-
-- **Python:** 3.9 through 3.12. Python 3.13 is not supported yet because `llama-cpp-python` does not support it.
+The `--extra-index-url` flag provides pre-built binaries for `llama-cpp-python`, making installation fast (~10 seconds). Without it, the C++ backend compiles from source (~5 minutes).
 
-## First-time build
+## Requirements
 
-`llama-cpp-python` may compile from source on first install. Expect roughly five minutes; this is normal.
+- **Python:** 3.9 through 3.13.
 
 ## Anaconda on Linux: OpenMP / libgomp errors
 
-If the build fails with `libgomp`-related errors, disable OpenMP for the GGML build:
+If the build fails with `libgomp`-related errors, disable OpenMP:
 
 ```bash
-CMAKE_ARGS="-DGGML_OPENMP=OFF" pip install --pre programasweights
+CMAKE_ARGS="-DGGML_OPENMP=OFF" pip install --pre programasweights --extra-index-url https://pypi.programasweights.com/simple/
 ```
 
 ## Cache and configuration

{programasweights-0.1.0.dev8 → programasweights-0.1.0.dev10}/docs/index.md

@@ -7,7 +7,7 @@ ProgramAsWeights lets you define functions in English and compile them into tiny
 ## Quick Start
 
 ```bash
-pip install --pre programasweights
+pip install --pre programasweights --extra-index-url https://pypi.programasweights.com/simple/
 ```
 
 ```python

{programasweights-0.1.0.dev8 → programasweights-0.1.0.dev10}/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.1.0.dev8"
+__version__ = "0.1.0.dev10"
 
 from .config import get_api_url, get_api_key, set_api_key
 

{programasweights-0.1.0.dev8 → programasweights-0.1.0.dev10}/programasweights/cache.py

@@ -4,7 +4,7 @@ Local cache management for base models and compiled programs.
 Cache structure:
     ~/.cache/programasweights/
         base_models/
-            qwen3-0.6b-q6k.gguf       # ~623 MB, downloaded once
+            qwen3-0.6b-q6_k.gguf      # ~623 MB, downloaded once
         programs/
             <program_id>/
                 adapter.gguf            # ~23 MB, Q4_0 LoRA
@@ -36,7 +36,12 @@ INTERPRETER_TO_GGUF = {
 
 def get_base_model_path(interpreter: str = "Qwen/Qwen3-0.6B") -> Path:
     """Get the path to the base model GGUF, downloading if needed."""
-    gguf_name = INTERPRETER_TO_GGUF.get(interpreter, "qwen3-0.6b-q6k")
+    gguf_name = INTERPRETER_TO_GGUF.get(interpreter)
+    if not gguf_name:
+        raise ValueError(
+            f"Unknown interpreter: '{interpreter}'. "
+            f"Supported: {list(INTERPRETER_TO_GGUF.keys())}"
+        )
     gguf_path = config.get_base_models_dir() / f"{gguf_name}.gguf"
 
     if gguf_path.exists():

{programasweights-0.1.0.dev8 → programasweights-0.1.0.dev10}/programasweights/cli.py

@@ -3,10 +3,11 @@
 ProgramAsWeights CLI.
 
 Usage:
-    paw compile <spec>             Compile a spec on the server
-    paw run <program_id> <input>   Run a program locally
-    paw login                      Authenticate with email
-    paw info <program_id>          Show program metadata
+    paw compile --spec "..."       Compile a spec on the server
+    paw run --program <id> --input "..."   Run a program locally
+    paw rename <program> <slug>    Set or change a program's slug
+    paw info <program>             Show program metadata
+    paw login [key]                Save API key for authentication
 
 All commands support --json for structured output (agent-friendly).
 """
@@ -63,6 +64,8 @@ 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
 
     fn = paw.function(
         args.program, verbose=args.verbose,
@@ -119,6 +122,8 @@ 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)

{programasweights-0.1.0.dev8 → programasweights-0.1.0.dev10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "programasweights"
-version = "0.1.0.dev8"
+version = "0.1.0.dev10"
 description = "Compile natural language specifications into neural programs that run locally via llama.cpp."
 readme = "PYPI_README.md"
 requires-python = ">=3.9"
@@ -28,7 +28,7 @@ classifiers = [
 ]
 dependencies = [
   "httpx>=0.27.0,<1.0",
-  "llama-cpp-python>=0.3.0,<1.0",
+  "llama-cpp-python>=0.3.0,<=0.3.18",
 ]
 
 [project.urls]

{programasweights-0.1.0.dev8 → programasweights-0.1.0.dev10}/server/api/routes/infer.py

@@ -43,7 +43,7 @@ async def run_inference(
     logger.info("infer_request", program_id=req.program_id,
                 input_len=len(req.input), max_tokens=req.max_tokens)
 
-    program = await resolve_program(req.program_id, db)
+    program = await resolve_program(req.program_id, db, user=user)
 
     if not program:
         raise HTTPException(status_code=404, detail={

{programasweights-0.1.0.dev8 → programasweights-0.1.0.dev10}/server/api/routes/programs.py

@@ -47,37 +47,49 @@ async def _get_owner_slug(program: Program, db: AsyncSession) -> str | None:
     return f"{row[0]}/{row[1]}" if row and row[0] else None
 
 
-async def resolve_program(id_or_slug: str, db: AsyncSession) -> Program | None:
+async def resolve_program(
+    id_or_slug: str,
+    db: AsyncSession,
+    user: User | None = None,
+    require_public: bool = True,
+) -> Program | None:
     """Resolve a program by hash ID or username/slug handle.
 
     Resolution order:
       1. Exact hash ID match
       2. If 'username/slug-name': join Alias + User where username and slug_name match
       3. If bare name (no /): try as programasweights official namespace
+
+    Privacy: if require_public is True (default), private programs are only
+    returned when the requesting user is the owner. Otherwise returns None.
     """
     result = await db.execute(select(Program).where(Program.id == id_or_slug))
     program = result.scalar_one_or_none()
-    if program:
-        return program
-
-    if "/" in id_or_slug:
-        username, slug_name = id_or_slug.split("/", 1)
-        result = await db.execute(
-            select(Program)
-            .join(Alias, Alias.program_id == Program.id)
-            .join(User, User.id == Alias.owner_id)
-            .where(User.username == username, Alias.slug_name == slug_name)
-        )
-        return result.scalar_one_or_none()
 
-    # Bare name: try official namespace (programasweights)
-    result = await db.execute(
-        select(Program)
-        .join(Alias, Alias.program_id == Program.id)
-        .join(User, User.id == Alias.owner_id)
-        .where(User.username == SYSTEM_NAMESPACE, Alias.slug_name == id_or_slug)
-    )
-    return result.scalar_one_or_none()
+    if not program:
+        if "/" in id_or_slug:
+            username, slug_name = id_or_slug.split("/", 1)
+            result = await db.execute(
+                select(Program)
+                .join(Alias, Alias.program_id == Program.id)
+                .join(User, User.id == Alias.owner_id)
+                .where(User.username == username, Alias.slug_name == slug_name)
+            )
+            program = result.scalar_one_or_none()
+        else:
+            result = await db.execute(
+                select(Program)
+                .join(Alias, Alias.program_id == Program.id)
+                .join(User, User.id == Alias.owner_id)
+                .where(User.username == SYSTEM_NAMESPACE, Alias.slug_name == id_or_slug)
+            )
+            program = result.scalar_one_or_none()
+
+    if program and require_public and not program.public:
+        if not user or user.id != program.author_id:
+            return None
+
+    return program
 
 
 # --- Tags ---
@@ -224,28 +236,45 @@ async def list_programs(
     programs = result.scalars().all()
 
     program_ids = [p.id for p in programs]
-    author_id_by_program = {p.id: p.author_id for p in programs}
-    all_alias_result = await db.execute(
+
+    # Fetch viewer's slugs (if logged in) and owner slugs in one query
+    alias_result = await db.execute(
         select(Alias.program_id, Alias.owner_id, User.username, Alias.slug_name)
         .join(User, User.id == Alias.owner_id)
-        .where(Alias.program_id.in_(program_ids))
+        .join(Program, Program.id == Alias.program_id)
+        .where(
+            Alias.program_id.in_(program_ids),
+            or_(
+                Alias.owner_id == Program.author_id,
+                Alias.owner_id == (user.id if user else -1),
+            ),
+        )
         .order_by(Alias.created_at)
     )
-    alias_map: dict[str, list[str]] = {}
-    for pid, owner_id, username, slug_name in all_alias_result.all():
+    viewer_slug_map: dict[str, str] = {}
+    owner_slug_map: dict[str, str] = {}
+    for pid, owner_id, username, slug_name in alias_result.all():
         if not username:
             continue
         handle = f"{username}/{slug_name}"
-        prog_author = author_id_by_program.get(pid)
-        if owner_id == prog_author:
-            alias_map.setdefault(pid, []).insert(0, handle)
+        if user and owner_id == user.id:
+            viewer_slug_map[pid] = handle
         else:
-            alias_map.setdefault(pid, []).append(handle)
+            owner_slug_map.setdefault(pid, handle)
+
+    def best_slug(pid: str) -> str | None:
+        return viewer_slug_map.get(pid) or owner_slug_map.get(pid)
+
+    alias_map: dict[str, list[str]] = {}
+    for pid in program_ids:
+        s = best_slug(pid)
+        if s:
+            alias_map[pid] = [s]
 
     def display_name(p):
-        aliases = alias_map.get(p.id, [])
-        if aliases:
-            return aliases[0].split("/")[-1]
+        slug = best_slug(p.id)
+        if slug:
+            return slug.split("/")[-1]
         return p.name
 
     author_ids = list({p.author_id for p in programs if p.author_id})
@@ -291,28 +320,19 @@ async def list_programs(
 
 
 @router.get("/programs/resolve/{slug:path}")
-async def resolve_slug(slug: str, db: AsyncSession = Depends(get_db)):
-    if "/" in slug:
-        username, slug_name = slug.split("/", 1)
-        result = await db.execute(
-            select(Alias.program_id, User.username, Alias.slug_name)
-            .join(User, User.id == Alias.owner_id)
-            .where(User.username == username, Alias.slug_name == slug_name)
-        )
-    else:
-        result = await db.execute(
-            select(Alias.program_id, User.username, Alias.slug_name)
-            .join(User, User.id == Alias.owner_id)
-            .where(User.username == SYSTEM_NAMESPACE, Alias.slug_name == slug)
-        )
-
-    row = result.first()
-    if not row:
+async def resolve_slug(
+    slug: str,
+    db: AsyncSession = Depends(get_db),
+    user: User | None = Depends(get_current_user),
+):
+    program = await resolve_program(slug, db, user=user)
+    if not program:
         raise HTTPException(status_code=404, detail={
             "error": "alias_not_found",
             "message": f"No program found with alias '{slug}'",
         })
-    return {"slug": f"{row[1]}/{row[2]}", "program_id": row[0]}
+    owner_slug = await _get_owner_slug(program, db)
+    return {"slug": owner_slug or slug, "program_id": program.id}
 
 
 @router.get("/programs/{id_or_slug}")
@@ -321,7 +341,7 @@ async def get_program(
     db: AsyncSession = Depends(get_db),
     user: User | None = Depends(get_current_user),
 ):
-    program = await resolve_program(id_or_slug, db)
+    program = await resolve_program(id_or_slug, db, user=user)
     if not program:
         raise HTTPException(status_code=404, detail={
             "error": "not_found",
@@ -380,8 +400,12 @@ async def get_program(
 
 
 @router.get("/programs/{id_or_slug}/download")
-async def download_program(id_or_slug: str, db: AsyncSession = Depends(get_db)):
-    program = await resolve_program(id_or_slug, db)
+async def download_program(
+    id_or_slug: str,
+    db: AsyncSession = Depends(get_db),
+    user: User | None = Depends(get_current_user),
+):
+    program = await resolve_program(id_or_slug, db, user=user)
     if not program:
         raise HTTPException(status_code=404, detail=f"Program '{id_or_slug}' not found")
 
@@ -395,12 +419,21 @@ async def download_program(id_or_slug: str, db: AsyncSession = Depends(get_db)):
 ALLOWED_ASSETS = {"adapter.gguf", "prompt_template.txt", "prefix_cache.bin", "prefix_tokens.json"}
 
 @router.get("/programs/{program_id}/asset/{filename}")
-async def serve_program_asset(program_id: str, filename: str):
+async def serve_program_asset(
+    program_id: str,
+    filename: str,
+    db: AsyncSession = Depends(get_db),
+    user: User | None = Depends(get_current_user),
+):
     if filename not in ALLOWED_ASSETS:
         raise HTTPException(status_code=400, detail="Invalid asset filename")
 
+    program = await resolve_program(program_id, db, user=user)
+    if not program:
+        raise HTTPException(status_code=404, detail="Asset not found")
+
     settings = get_settings()
-    asset_path = Path(settings.STORAGE_PATH) / program_id / filename
+    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")
 
@@ -422,7 +455,7 @@ async def update_program(
     user: User = Depends(require_user),
     db: AsyncSession = Depends(get_db),
 ):
-    program = await resolve_program(id_or_slug, db)
+    program = await resolve_program(id_or_slug, db, user=user)
     if not program:
         raise HTTPException(status_code=404, detail="Program not found")
 
@@ -495,7 +528,7 @@ async def vote_program(
     user: User = Depends(require_user),
     db: AsyncSession = Depends(get_db),
 ):
-    program = await resolve_program(id_or_slug, db)
+    program = await resolve_program(id_or_slug, db, user=user)
     if not program:
         raise HTTPException(status_code=404, detail="Program not found")
 
@@ -548,8 +581,9 @@ async def get_cases(
     page: int = 1,
     page_size: int = 20,
     db: AsyncSession = Depends(get_db),
+    user: User | None = Depends(get_current_user),
 ):
-    program = await resolve_program(id_or_slug, db)
+    program = await resolve_program(id_or_slug, db, user=user)
     if not program:
         raise HTTPException(status_code=404, detail="Program not found")
 
@@ -604,8 +638,9 @@ async def create_case(
     id_or_slug: str,
     request: Request,
     db: AsyncSession = Depends(get_db),
+    user: User | None = Depends(get_current_user),
 ):
-    program = await resolve_program(id_or_slug, db)
+    program = await resolve_program(id_or_slug, db, user=user)
     if not program:
         raise HTTPException(status_code=404, detail="Program not found")
 
@@ -632,7 +667,7 @@ async def create_alias(
     user: User = Depends(require_user),
     db: AsyncSession = Depends(get_db),
 ):
-    program = await resolve_program(program_id, db)
+    program = await resolve_program(program_id, db, user=user)
     if not program:
         raise HTTPException(status_code=404, detail="Program not found")
 

programasweights-0.1.0.dev10/tests/test_offline_cache.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""
+Test that PAW functions work offline after first use.
+
+Step 1 (warm): Call paw.function() with a slug to populate caches.
+Step 2 (cold offline): In a NEW process with all network blocked,
+       call paw.function() with the same slug and run inference.
+
+Usage:
+    python3 tests/test_offline_cache.py
+"""
+
+import json
+import subprocess
+import sys
+import os
+
+SLUG = "programasweights/email-triage"
+
+STEP1_SCRIPT = '''
+import programasweights as paw
+from programasweights.cache import _slug_cache_path, get_cached_slug
+import json
+
+print("Step 1: Warming cache with network...")
+fn = paw.function("{slug}")
+result = fn("Server is down, need immediate help!")
+print(f"  Result: {{result}}")
+
+# Verify slug cache was saved
+path = _slug_cache_path()
+assert path.exists(), "slug_cache.json was not created!"
+data = json.loads(path.read_text())
+assert "{slug}" in data, "Slug not in cache!"
+program_id = data["{slug}"]
+print(f"  Cached slug -> {{program_id}}")
+print("  STEP 1 PASSED")
+'''.format(slug=SLUG)
+
+STEP2_SCRIPT = '''
+import socket
+
+# Block ALL network access before importing anything PAW-related
+_real_connect = socket.socket.connect
+def _blocked_connect(self, *args, **kwargs):
+    raise OSError("NETWORK BLOCKED: offline test detected a network call!")
+socket.socket.connect = _blocked_connect
+
+# Also block DNS resolution
+_real_getaddrinfo = socket.getaddrinfo
+def _blocked_getaddrinfo(*args, **kwargs):
+    raise OSError("DNS BLOCKED: offline test detected a DNS lookup!")
+socket.getaddrinfo = _blocked_getaddrinfo
+
+import programasweights as paw
+
+print("Step 2: Cold start with ALL network blocked...")
+fn = paw.function("{slug}")
+result = fn("Meeting notes from yesterday - please review")
+print(f"  Result: {{result}}")
+print("  STEP 2 PASSED: Function works fully offline!")
+'''.format(slug=SLUG)
+
+
+def main():
+    python = sys.executable
+
+    print("=" * 60)
+    print("PAW Offline Cache Test")
+    print("=" * 60)
+    print()
+
+    # Step 1: warm cache
+    r = subprocess.run([python, "-c", STEP1_SCRIPT], capture_output=True, text=True)
+    print(r.stdout)
+    if r.returncode != 0:
+        print(f"STEP 1 FAILED:\n{r.stderr}")
+        return 1
+
+    print()
+
+    # Step 2: cold offline (new process, network blocked)
+    r = subprocess.run([python, "-c", STEP2_SCRIPT], capture_output=True, text=True)
+    print(r.stdout)
+    if r.returncode != 0:
+        print(f"STEP 2 FAILED:\n{r.stderr}")
+        return 1
+
+    print()
+    print("=" * 60)
+    print("ALL PASSED: PAW functions work offline after first use.")
+    print("=" * 60)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())