programasweights 0.4.7__tar.gz → 0.4.8__tar.gz

{programasweights-0.4.7 → programasweights-0.4.8}/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.4.8 (2026-09-20)
+
+- Reduce the source distribution to the SDK and files needed to build and
+  document the package.
+
 ## 0.4.7 (2026-09-20)
 
 - Add `remote=True` to `paw.function` and `paw.compile_and_load`, plus

{programasweights-0.4.7 → programasweights-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: programasweights
-Version: 0.4.7
+Version: 0.4.8
 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.7 → programasweights-0.4.8}/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.7"
+    __version__ = "0.4.8"
 
 from ._output import ProgressCallback, ProgressEvent, report_progress
 from .cache import CachedProgram

{programasweights-0.4.7 → programasweights-0.4.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "programasweights"
-version = "0.4.7"
+version = "0.4.8"
 description = "Compile natural language specifications into neural programs that run locally via llama.cpp."
 readme = "PYPI_README.md"
 requires-python = ">=3.9"
@@ -47,6 +47,16 @@ paw = "programasweights.cli:main"
 [tool.hatch.build.targets.wheel]
 packages = ["programasweights"]
 
+[tool.hatch.build.targets.sdist]
+only-include = [
+  "programasweights",
+  "README.md",
+  "PYPI_README.md",
+  "LICENSE",
+  "CHANGELOG.md",
+  "pyproject.toml",
+]
+
 [tool.pytest.ini_options]
 addopts = "-q"
 pythonpath = ["."]

programasweights-0.4.7/.cursor/rules/releases.mdc

@@ -1,17 +0,0 @@
----
-description: Publish and verify complete Python SDK releases
-alwaysApply: true
----
-
-# SDK releases
-
-For release or publication work, read `RELEASING.md` first.
-
-- A release is complete only when its annotated remote tag, PyPI wheel and
-  source distribution, and published GitHub Release all exist and agree.
-- Build from the clean, tested release commit; push its annotated version tag
-  before uploading the exact checked artifacts to PyPI.
-- Verify the `GitHub release` workflow succeeded and the latest GitHub Release
-  agrees with PyPI. A tag alone is not a GitHub Release entry.
-- Repair missing entries using the documented workflow dispatch. Never move a
-  published tag, rebuild an existing version, or bypass artifact verification.

programasweights-0.4.7/.github/workflows/release.yml

@@ -1,72 +0,0 @@
-name: GitHub release
-
-on:
-  push:
-    tags: ['v*']
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: 'Existing stable version tag, e.g. v0.4.6'
-        required: true
-        type: string
-
-permissions:
-  contents: write
-
-concurrency:
-  group: github-release-${{ inputs.tag || github.ref_name }}
-  cancel-in-progress: false
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    env:
-      RELEASE_TAG: ${{ inputs.tag || github.ref_name }}
-      GH_TOKEN: ${{ github.token }}
-      GH_REPO: ${{ github.repository }}
-    steps:
-      - name: Set the verification output directory
-        run: echo "RELEASE_DIR=$RUNNER_TEMP/verified-release" >> "$GITHUB_ENV"
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - name: Verify the remote tag and both published PyPI artifacts
-        # Tags are pushed before uploading. Wait for the wheel AND sdist;
-        # never announce an unpublished version or rebuild release assets.
-        run: python scripts/release_metadata.py --tag "$RELEASE_TAG" --output-dir "$RELEASE_DIR" --wait-seconds 600
-      - name: Publish the missing GitHub release
-        shell: bash
-        run: |
-          set -euo pipefail
-          if gh release view "$RELEASE_TAG" --json tagName >/dev/null 2>&1; then
-            echo "Release already exists; preserving its notes and assets."
-          else
-            latest=$(jq -r .latest "$RELEASE_DIR/verified.json")
-            gh release create "$RELEASE_TAG" "$RELEASE_DIR"/artifacts/* \
-              --verify-tag --title "$RELEASE_TAG" \
-              --notes-file "$RELEASE_DIR/notes.md" --latest="$latest"
-          fi
-          gh release view "$RELEASE_TAG" --json tagName,isDraft,isPrerelease,url \
-            | jq -e --arg tag "$RELEASE_TAG" '.tagName == $tag and .isDraft == false and .isPrerelease == false'
-      - name: Verify the uploaded release assets and latest marker
-        shell: bash
-        run: |
-          set -euo pipefail
-          gh release download "$RELEASE_TAG" --pattern 'programasweights-*' \
-            --dir "$RELEASE_DIR/github-assets"
-          for artifact in "$RELEASE_DIR"/artifacts/*; do
-            cmp "$artifact" "$RELEASE_DIR/github-assets/$(basename "$artifact")"
-          done
-          if [ "$(jq -r .latest "$RELEASE_DIR/verified.json")" = true ]; then
-            gh api "repos/$GH_REPO/releases/latest" \
-              | jq -e --arg tag "$RELEASE_TAG" '.tag_name == $tag'
-          fi
-      - name: Retain the verification record
-        uses: actions/upload-artifact@v4
-        with:
-          name: release-verification-${{ inputs.tag || github.ref_name }}
-          path: ${{ runner.temp }}/verified-release/verified.json

programasweights-0.4.7/.github/workflows/test.yml

@@ -1,94 +0,0 @@
-name: tests
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-
-jobs:
-  release-metadata:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - run: python -m pip install pytest
-      - name: Test release verification without network or publishing
-        run: python -m pytest tests/test_release_metadata.py
-
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Install (hermetic deps only)
-        # Install httpx + pytest and the package itself without pulling the heavy
-        # llama-cpp-python build. Runtime tests inject a fake llama_cpp module,
-        # so CI needs neither the native extension nor a model download.
-        run: |
-          python -m pip install --upgrade pip
-          python -m pip install httpx pytest
-          python -m pip install -e . --no-deps
-
-      - name: Run hermetic tests
-        # Scoped to tests that need no network, no model download, and no
-        # PAW_API_KEY. Auth tests (@needs_auth) auto-skip without a key; the
-        # network/model-download tests in test_sdk.py are excluded here and can
-        # be run separately against a live server.
-        run: |
-          pytest \
-            tests/test_api_errors.py \
-            tests/test_compile_timeouts.py \
-            tests/test_local_program.py \
-            tests/test_base_interpreter.py \
-            tests/test_cli_auth.py \
-            tests/test_remote_inference.py \
-            tests/test_desktop_sdk.py \
-            tests/test_runtime_registry_sdk.py \
-            tests/test_sdk.py::TestInstallAndImport
-
-  local-files-windows:
-    runs-on: windows-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-      - name: Install hermetic test dependencies
-        run: |
-          python -m pip install httpx pytest
-          python -m pip install -e . --no-deps
-      - name: Test Windows local paths, cache locks, and compile errors
-        run: python -m pytest tests/test_api_errors.py tests/test_compile_timeouts.py tests/test_local_program.py tests/test_remote_inference.py --junitxml=test-results.xml
-      - name: Annotate Windows test failures
-        if: failure()
-        shell: python
-        run: |
-          from pathlib import Path
-          import xml.etree.ElementTree as ET
-
-          report = Path("test-results.xml")
-          if report.exists():
-              for case in ET.parse(report).iter("testcase"):
-                  for result in case:
-                      if result.tag in {"failure", "error"}:
-                          # GitHub truncates annotations, so retain the actual
-                          # exception at the end of long pytest tracebacks.
-                          detail = result.text or result.get("message", "")
-                          message = f"{case.get('name')}: {detail[-3500:]}"
-                          message = message.replace("%", "%25").replace("\r", "%0D").replace("\n", "%0A")
-                          print(f"::error::{message}")

programasweights-0.4.7/.readthedocs.yaml

@@ -1,13 +0,0 @@
-version: 2
-
-build:
-  os: ubuntu-24.04
-  tools:
-    python: "3.12"
-
-mkdocs:
-  configuration: mkdocs.yml
-
-python:
-  install:
-    - requirements: docs/requirements.txt

programasweights-0.4.7/AGENTS.md

@@ -1,291 +0,0 @@
-# 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
-Full documentation: https://programasweights.readthedocs.io
-
-## 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
-
-## Install
-
-```bash
-pip install programasweights --extra-index-url https://pypi.programasweights.com/simple/
-```
-
-## Quickstart
-
-```python
-import programasweights as paw
-
-# Use a pre-compiled function (downloads once, runs locally forever)
-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"
-)
-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"
-```
-
-Load a local `.paw` file with `paw.function("./classifier.paw")` (SDK 0.4.5+).
-
-If you want the smaller browser-compatible runtime explicitly, pass `compiler="paw-4b-gpt2"`. Otherwise, omit `compiler` and let the server default decide.
-
-## Remote inference (optional)
-
-Use the hosted API for fast inference in around 150 ms, without a local model download.
-
-### Python SDK
-
-```python
-import programasweights as paw
-
-with paw.function("email-triage", remote=True) as remote_fn:
-    print(remote_fn("Urgent: the server is down!"))
-```
-
-For authenticated requests, set `PAW_API_KEY` or use `paw.login()`.
-
-### Direct HTTP
-
-Use `httpx` directly without installing the PAW SDK.
-
-```python
-import httpx
-
-with httpx.Client(timeout=60.0) as client:
-    response = client.post(
-        "https://programasweights.com/api/v1/infer",
-        json={
-            "program_id": "email-triage",
-            "input": "Urgent: server is down!"
-        },
-    )
-    response.raise_for_status()
-    print(response.json()["output"])
-```
-
-For authenticated requests, pass `headers={"X-API-Key": api_key}` to `client.post()`.
-
-## Current Public Compilers
-
-- **Standard** (`paw-4b-qwen3-0.6b`) — higher accuracy, 594 MB base + ~22 MB/program. This is the current server default.
-- **Compact** (`paw-4b-gpt2`) — smaller (134 MB base + ~5 MB/program), runs in browser via WebAssembly.
-
-Best practice:
-
-- For quickstarts and reusable agent workflows, prefer `paw.compile(spec)` with no explicit compiler.
-- If you need to target a specific runtime, pass `compiler="paw-4b-gpt2"` or another supported alias explicitly.
-- If you need to inspect current server-supported compiler names at runtime, call `paw.list_compilers()`.
-
-## Writing Good Specs
-
-**The #1 practice: iterate with test cases.** Do not accept low performance on the first try. Build a test suite of input/output pairs, measure accuracy, then iteratively adjust wording and formatting until performance is good enough. Treat spec writing like software engineering: test, debug specific failures, fix the wording, retest.
-
-A good spec has a description plus `Input: ... Output: ...` examples.
-
-```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
-""")
-```
-
-**Spec-tuning tips:**
-
-- **State output constraints explicitly**: "Return ONLY one of: X, Y, Z". Without this the model may produce free-form text.
-- **Include examples from your actual data**: Examples outperform prose-only descriptions.
-- **Debug failures before sweeping**: Look at specific failing examples and understand WHY before trying many variants.
-
-## Constraints And Runtime Behavior
-
-- Each PAW function is stateless: one text input, one text output. No conversation history.
-- Spec + input + output share a ~2048 token context window. Inputs that exceed it will error.
-- `max_tokens` defaults to `None`: generation runs until EOS or the context limit.
-- Compile runs on the hosted PAW API. Inference should usually run locally through the SDK.
-- Synchronous compile requests use a 40-minute read timeout.
-- **Run local inference sequentially by default.** With PAW’s current llama.cpp backend, simultaneous inference calls often perform worse. Reuse loaded functions and process inputs one at a time; never call the same function instance concurrently.
-- **GPU acceleration** is enabled by default (`n_gpu_layers=-1`). Uses Metal on Mac, CUDA on Linux, and falls back to CPU automatically. If GPU causes issues, set `PAW_GPU_LAYERS=0` or pass `n_gpu_layers=0`.
-- **First call** is usually ~1-5s because it loads the base model. Subsequent calls are typically ~0.05-0.5s depending on input length and GPU availability.
-- **Base model files are shared** across programs on disk. Each Standard LoRA adapter is ~22 MB; each Compact LoRA adapter is ~5 MB.
-- Cache root is `~/.cache/programasweights/`. Override with `PAW_CACHE_DIR`.
-- After the first download, inference works offline. Pass `offline=True` or set
-  `PAW_OFFLINE=1` to prohibit network access and fail if any validated asset is
-  missing.
-- Advanced only: `paw.function(None, interpreter="gpt2")` runs a supported
-  base model without a compiled adapter; consult the Python API reference for
-  its strict prompt and offline semantics.
-
-## Common Errors
-
-Compile API HTTP errors raise `paw.APIError`. Check `error.code` and `error.message` for details. The SDK does not retry automatically.
-
-| Error | Cause | Fix |
-|-------|-------|-----|
-| `RuntimeError: assets not ready` on download | Program is still generating after compile | The SDK polls automatically for up to 60s. If it still fails, retry shortly or recompile. |
-| `httpx.HTTPStatusError: 422` on compile | Spec too short (<10 chars) or request validation failed | Adjust spec length or request shape. |
-| `httpx.HTTPStatusError: 429` | Hosted compile API limit exceeded | Wait, or sign in for higher compile limits. |
-| GPU/Metal errors on load | GPU backend not available or incompatible | Set `PAW_GPU_LAYERS=0` or pass `n_gpu_layers=0` to force CPU. |
-
-## 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('email-triage-browser');
-const result = await fn('Urgent: server is down!');
-// result: "immediate"
-```
-
-The browser SDK resolves slugs through the PAW API, then downloads browser assets from Hugging Face and runs inference client-side. If you load by program ID, browser inference stays independent of the PAW API at runtime.
-
-## 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 |
-| Concurrent compile requests | 1 | 2 |
-| Name programs (slugs) | No | Yes |
-
-Hosted API limits apply to compile requests. Most inference should run locally through the SDK.
-
-## CLI
-
-Commands: `paw compile --spec "..." --json`, `paw run --program <id> --input "..." [--offline]`, `paw info <id>`, `paw rename <id> <slug>`, `paw login`. All support `--json` for structured output.
-
-## Versioning
-
-Slugs support version history. Recompiling with the same slug creates a new version:
-
-```python
-p1 = paw.compile("Count words v1", slug="word-counter")  # v1
-p2 = paw.compile("Count words v2", slug="word-counter")  # v2 (auto-bumps)
-
-fn = paw.function("da03/word-counter")     # resolves to main (latest)
-fn = paw.function("da03/word-counter@v1")  # pinned to v1
-
-versions = paw.list_versions("da03/word-counter")  # all versions
-```
-
-Pinned versions (`@v1`) are immutable and cached locally forever. Bare slugs always check the server for the latest main version and fall back to cache if offline.
-
-## Full API Reference
-
-```python
-program = paw.compile(
-    spec,                               # natural language specification (10-16000 chars)
-    compiler=None,                      # omit to use the current server default (today: paw-4b-qwen3-0.6b)
-    slug=None,                          # URL-safe handle (requires auth)
-    public=True,                        # list on public hub
-)
-# Returns: Program(id, slug, status, version, version_action, timings, error)
-
-fn = paw.function(program)              # accepts Program object, hash ID, or slug
-fn = paw.function("a6b454023d41ac9ca845")
-fn = paw.function("da03/my-classifier")
-fn = paw.function("da03/my-classifier@v2")  # pinned version
-fn = paw.function("da03/my-classifier", offline=True)  # skip server check
-
-result: str = fn(input_text: str, max_tokens=None, temperature=0.0)
-
-prepared = paw.prepare_program("da03/my-classifier")
-ready = paw.is_offline_ready("da03/my-classifier")  # zero network
-cached = paw.list_cached_programs()
-
-fn = paw.compile_and_load(spec)
-
-job = paw.compile_async(spec, compiler="paw-ft-bs48")  # explicit finetune compiler required
-status = paw.get_compile_status(job["job_id"])
-
-versions = paw.list_versions("da03/my-classifier")  # version history
-programs = paw.list_programs(sort="recent", per_page=20)  # requires auth
-compilers = paw.list_compilers()  # discover available compilers at runtime
-
-paw.login()
-```
-
-## Chaining Functions
-
-Multiple PAW functions can be composed for multi-step tasks:
-
-```python
-classifier = paw.compile_and_load("Classify the bug type. Return ONLY one of: off-by-one, type-error, other")
-fixer = paw.compile_and_load("Fix the bug described in the first line. Return only the corrected code.")
-
-label = classifier(code_snippet)
-if label != "other":
-    fix = fixer(f"{label}: {code_snippet}")
-```
-
-Chain them with regular Python logic.
-
-## Worked Example: Log Monitoring
-
-PAW functions can classify log output. Compile once with examples from your specific logs, then reuse the function locally forever:
-
-```python
-program = paw.compile("""
-Classify log lines. Return ONLY one word: ALERT or QUIET.
-
-Input: [step 100] loss=0.05 lr=0.0001
-Output: QUIET
-
-Input: [Checkpoint] Saved model at step 1000
-Output: ALERT
-
-Input: Traceback (most recent call last):
-Output: ALERT
-
-Input: Training complete. Final loss: 0.11
-Output: ALERT
-""")
-
-fn = paw.function(program.id)  # reuse with saved program.id
-fn("[step 200] loss=0.04")           # "QUIET"
-fn("[Checkpoint] Saved model")       # "ALERT"
-```
-
-Full tool with file watching, truncation, and stall detection: [examples/paw_monitor.py](https://github.com/programasweights/programasweights-python/blob/main/examples/paw_monitor.py)
-
-## Case Studies
-
-Detailed walkthroughs of building production systems with PAW, including what we tried and what we learned: [log monitoring](https://programasweights.readthedocs.io/en/latest/case-studies/log-monitoring/), [site navigation](https://programasweights.readthedocs.io/en/latest/case-studies/site-navigation/), [semantic search](https://programasweights.readthedocs.io/en/latest/case-studies/semantic-search/), [tool calling](https://programasweights.readthedocs.io/en/latest/case-studies/tool-calling/).
-

programasweights-0.4.7/RELEASING.md

@@ -1,82 +0,0 @@
-# Releasing the Python SDK
-
-A release has three separate records: an annotated Git tag identifies the source,
-PyPI serves the installable wheel and source distribution, and a GitHub Release
-shows the version and release notes on the repository. A tag or PyPI upload alone
-does not create a GitHub Release. Finish and verify all three before reporting a
-release complete.
-
-## Publish a new version
-
-1. Update `pyproject.toml`, the fallback `__version__` in
-   `programasweights/__init__.py`, and the matching section in `CHANGELOG.md`.
-   Commit and push these changes to `main` using the existing user Git identity.
-   Release from a clean checkout of that pushed commit; confirm `HEAD` equals
-   `origin/main` and the `tests` workflow is green for that exact commit.
-2. Set the intended version, then build a wheel and source distribution into a
-   new, empty directory. Install `build` and `twine` in the release environment if
-   needed. Use the two exact filenames below, not a shared `dist/*` directory.
-
-   ```bash
-   SDK_RELEASE_VERSION=0.4.7  # replace with the version being released
-   SDK_RELEASE_DIR=$(mktemp -d)
-   python -m build --outdir "$SDK_RELEASE_DIR"
-   python -m twine check \
-     "$SDK_RELEASE_DIR/programasweights-$SDK_RELEASE_VERSION-py3-none-any.whl" \
-     "$SDK_RELEASE_DIR/programasweights-$SDK_RELEASE_VERSION.tar.gz"
-   ```
-
-3. Create and push the annotated version tag **before uploading to PyPI**. Check
-   that the remote tag resolves to the intended commit and is an annotated tag.
-   Never replace an existing release tag with a new target.
-
-   ```bash
-   git tag -a "v$SDK_RELEASE_VERSION" -m "Release v$SDK_RELEASE_VERSION"
-   git push origin "v$SDK_RELEASE_VERSION"
-   git ls-remote --tags origin "refs/tags/v$SDK_RELEASE_VERSION*"
-   ```
-
-4. Upload the exact wheel and source distribution that passed `twine check`:
-
-   ```bash
-   python -m twine upload \
-     "$SDK_RELEASE_DIR/programasweights-$SDK_RELEASE_VERSION-py3-none-any.whl" \
-     "$SDK_RELEASE_DIR/programasweights-$SDK_RELEASE_VERSION.tar.gz"
-   ```
-
-5. The `release.yml` workflow starts on the `v*` tag push. It waits up to 600
-   seconds for PyPI, verifies the remote annotated tag, version metadata, and
-   published wheel/source distribution against the tagged source, then creates
-   the GitHub Release with notes from that tag's `CHANGELOG.md` and the published
-   artifacts. It preserves an existing release and marks a new release as latest
-   only when its version is the latest on PyPI. If upload takes longer than the
-   wait window, dispatch the workflow again after PyPI publication succeeds.
-6. Verify the workflow succeeded, the GitHub Releases page has the expected entry
-   and notes, and the latest-release entry agrees with PyPI's latest version.
-   Compare both uploaded files' SHA-256 hashes with the version's PyPI JSON
-   (`https://pypi.org/pypi/programasweights/<version>/json`, `urls[].digests.sha256`)
-   and with the GitHub Release assets. Do not treat a tag listing as confirmation
-   that the release entry exists.
-
-## Recover a missing GitHub Release
-
-When a version already exists on PyPI, keep its existing tag and published files.
-Do not rebuild or republish that version, and never move its tag. Verify the
-remote annotated tag, matching version metadata and changelog section, and the
-published artifacts first. `scripts/release_metadata.py` requires Python 3.11+
-and performs those checks, preparing the notes and assets in a new directory:
-
-```bash
-SDK_RELEASE_RECOVERY_DIR=$(mktemp -d)
-git fetch origin --tags
-python scripts/release_metadata.py --tag v0.4.6 \
-  --output-dir "$SDK_RELEASE_RECOVERY_DIR/verified" --wait-seconds 600
-gh workflow run release.yml --ref main -f tag=v0.4.6
-```
-
-Replace `v0.4.6` with the verified existing tag to repair. Run this from current
-`main`, which contains the recovery workflow and script; the release content is
-read from the requested tag. The workflow is idempotent: an existing GitHub
-Release is preserved. Recheck the release entry, latest-version status, and
-artifact hashes after it finishes. A source or artifact mismatch needs
-investigation; do not retag or overwrite published artifacts to make it pass.

programasweights-0.4.7/docs/adr/001-llama-cpp-over-pytorch.md

@@ -1,21 +0,0 @@
-# ADR-001: Use llama.cpp instead of PyTorch for SDK runtime
-
-## Status: Accepted (2026-03-21)
-
-## Context
-
-The SDK currently depends on torch + transformers (~2GB install). Users expect a lightweight package they can `pip install` in seconds. Most users run on CPU-only machines (laptops, desktops). The .paw format v2 stores raw safetensors LoRA weights that require PyTorch to apply.
-
-## Decision
-
-Replace the PyTorch runtime with llama-cpp-python (~80MB install). Use GGUF model format for the base interpreter and Q4_0 quantized GGUF LoRA adapters. Pre-render chat templates server-side so the client needs no tokenizer library.
-
-## Consequences
-
-- Install size drops from ~2GB to ~80MB (25x reduction)
-- Users no longer need CUDA, PyTorch, or transformers
-- Inference uses Metal (Mac), CPU (Linux/Windows) — no GPU required
-- Must pre-render chat templates server-side (no transformers tokenizer on client)
-- .paw format must change from v2 (safetensors) to v3 (GGUF adapter)
-- Base model is downloaded once (~594 MB Q6_K for Qwen3, ~134 MB Q8_0 for GPT-2) and shared across all functions
-- Per-function adapter download is ~23MB (Q4_0, confirmed lossless at 4096-scale eval)