programasweights 0.4.4__tar.gz → 0.4.5__tar.gz

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

@@ -0,0 +1,82 @@
+name: tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  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_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 --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.4 → programasweights-0.4.5}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.4.5 (2026-09-10)
+
+- Expose structured compile API failures as `paw.APIError`, compatible with
+  `httpx.HTTPStatusError`, preserving server code, message, request ID, and the
+  original response. Transport errors propagate unchanged; no automatic retries.
+- Allow synchronous compilation a 2,400-second read timeout while keeping
+  connect, write, and pool timeouts at 120 seconds. Async submission stays at
+  30 seconds; precheck, status, and cancellation stay at 10 seconds.
+- Load current GGUF ZIP `.paw` files through `paw.function` using explicit
+  local paths or `Path` objects. Validated imports use a separate SHA-256 cache
+  without replacing Hub caches or source files; invalid local files never fall
+  back to Hub lookup. Shared base-model assets may still need downloading unless
+  offline mode is requested. Legacy tensor-format `.paw` files are unsupported.
+
 ## 0.4.4 (2026-07-18)
 
 - Add desktop preparation and cache inspection APIs with structured progress:

{programasweights-0.4.4 → programasweights-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: programasweights
-Version: 0.4.4
+Version: 0.4.5
 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
@@ -102,6 +102,19 @@ finetune compiles can be queued with
 `paw.compile_async(spec, compiler="paw-ft-bs48")`; an explicit finetune
 compiler is required.
 
+Load a saved current GGUF ZIP `.paw` bundle directly (SDK 0.4.5+):
+
+```python
+from pathlib import Path
+fn = paw.function(Path("classifier.paw"))
+```
+
+Local files are validated into a separate SHA-256 cache without changing the
+source or falling back to Hub lookup. Runtime metadata or the shared base model
+may still download; `offline=True` prohibits those requests. Legacy tensor-format
+`.paw` files are unsupported. Local-file inputs are supported by `function`,
+not `prepare_program` or `is_offline_ready`.
+
 Advanced adapter-free inference is available with
 `paw.function(None, interpreter="gpt2")`; see the Python API reference for
 its intentionally strict semantics.
@@ -179,4 +192,4 @@ paw login
 
 ## License
 
-MIT
+MIT

{programasweights-0.4.4 → programasweights-0.4.5}/PYPI_README.md

@@ -71,6 +71,19 @@ finetune compiles can be queued with
 `paw.compile_async(spec, compiler="paw-ft-bs48")`; an explicit finetune
 compiler is required.
 
+Load a saved current GGUF ZIP `.paw` bundle directly (SDK 0.4.5+):
+
+```python
+from pathlib import Path
+fn = paw.function(Path("classifier.paw"))
+```
+
+Local files are validated into a separate SHA-256 cache without changing the
+source or falling back to Hub lookup. Runtime metadata or the shared base model
+may still download; `offline=True` prohibits those requests. Legacy tensor-format
+`.paw` files are unsupported. Local-file inputs are supported by `function`,
+not `prepare_program` or `is_offline_ready`.
+
 Advanced adapter-free inference is available with
 `paw.function(None, interpreter="gpt2")`; see the Python API reference for
 its intentionally strict semantics.
@@ -148,4 +161,4 @@ paw login
 
 ## License
 
-MIT
+MIT

{programasweights-0.4.4 → programasweights-0.4.5}/README.md

@@ -71,6 +71,19 @@ finetune compiles can be queued with
 `paw.compile_async(spec, compiler="paw-ft-bs48")`; an explicit finetune
 compiler is required.
 
+Load a saved current GGUF ZIP `.paw` bundle directly (SDK 0.4.5+):
+
+```python
+from pathlib import Path
+fn = paw.function(Path("classifier.paw"))
+```
+
+Local files are validated into a separate SHA-256 cache without changing the
+source or falling back to Hub lookup. Runtime metadata or the shared base model
+may still download; `offline=True` prohibits those requests. Legacy tensor-format
+`.paw` files are unsupported. Local-file inputs are supported by `function`,
+not `prepare_program` or `is_offline_ready`.
+
 Advanced adapter-free inference is available with
 `paw.function(None, interpreter="gpt2")`; see the
 [Python API reference](docs/api-reference/python-sdk.md#advanced-adapter-free-base-interpreter)
@@ -149,4 +162,4 @@ paw login
 
 ## License
 
-MIT
+MIT

{programasweights-0.4.4 → programasweights-0.4.5}/docs/api-reference/python-sdk.md

@@ -28,15 +28,17 @@ fn = paw.function(
 )
 ```
 
-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.
+Loads a compiled program and returns a callable. Hub references download the
+program and base model on first use; local `.paw` files supply the program
+bundle directly. Required runtime metadata and base models are cached for reuse.
 
 | Parameter | Description |
 |-----------|-------------|
-| `program_id` | Required. A `Program` object, hash ID (e.g. `a6b454023d41ac9ca845`), slug (e.g. `da03/my-classifier`), or official shorthand (e.g. `email-triage`). A `Program` resolves by immutable `id`, not its mutable slug. |
+| `program_id` | Required. A `Program` object, hash ID (e.g. `a6b454023d41ac9ca845`), slug (e.g. `da03/my-classifier`), official shorthand (e.g. `email-triage`), or local `.paw` path (see below). A `Program` resolves by immutable `id`, not its mutable slug. |
 | `n_ctx` | Context length for the local runtime (default `2048`). |
 | `n_gpu_layers` | GPU layers to offload (`0` = CPU-only, `-1` = all). The default is `-1`, or `PAW_GPU_LAYERS` when set. |
 | `verbose` | Enable verbose logging (default `False`). |
-| `offline` | Require all program/runtime/model assets to already be cached and make zero network calls. `PAW_OFFLINE=1` has the same effect. |
+| `offline` | Use only local files/cache and make zero network calls; fail if required validated assets are missing. `PAW_OFFLINE=1` has the same effect. |
 | `interpreter` | Advanced adapter-free mode only. Must be passed by keyword and only when `program_id` is explicitly `None`. Supported values are `Qwen/Qwen3-0.6B` and `gpt2`. |
 
 The returned callable:
@@ -54,7 +56,7 @@ output: str = fn(input_text, max_tokens=None, temperature=0.0)
 **Context limits:** Spec + input + output share a ~2048 token window. Inputs that exceed it will error. `max_tokens` defaults to `None`: generation runs until EOS or the context limit.
 
 Compiled mode is strict: the adapter, prompt template, matching metadata,
-runtime manifest, and runtime-compatible base-model file must all validate. Version 0.4.4
+runtime manifest, and runtime-compatible base-model file must all validate. Version 0.4.5
 accepts runtime manifest version 1 with `adapter_format="gguf_lora"`.
 Built-in models are checked against pinned size/SHA-256 metadata and GGUF
 magic. Historical manifests for those known runtime IDs are normalized to the
@@ -62,6 +64,45 @@ same canonical integrity metadata, so missing server-side checksum fields
 cannot weaken validation. Missing or failed adapters raise an error; the SDK
 never silently falls back to an unadapted base model.
 
+### Loading a local `.paw` file
+
+Version 0.4.5 adds local-file inputs to `paw.function`:
+
+```python
+from pathlib import Path
+
+fn = paw.function(Path("classifier.paw"))
+# With the required runtime metadata and base model already available locally:
+fn = paw.function("./classifier.paw", offline=True)
+```
+
+Use a current GGUF ZIP `.paw` bundle, such as one downloaded from a hosted
+compile. It must contain `meta.json`, `adapter.gguf`, and `prompt_template.txt`,
+with only `pseudo_program.txt` allowed as an optional extra; serialized native
+prefix state is not accepted from archives. Local inputs are selected
+deterministically: a `Path`/`os.PathLike`
+object, an explicit path such as `./classifier.paw` or an absolute path, or a
+string ending in `.paw` (case-insensitive). Ordinary IDs and slugs such as
+`da03/my-classifier` keep their existing Hub behavior even if a matching local
+file exists. Use `Path(...)` or an explicit path for a filename without the
+`.paw` suffix. URL inputs are unsupported.
+
+The bundle is validated and imported under
+`PAW_CACHE_DIR/local_programs/<archive-sha256>` (default cache root:
+`~/.cache/programasweights`). Its source file is unchanged, and its metadata
+cannot replace a Hub program-ID or slug cache. Missing or invalid local files
+raise an error without falling back to a Hub lookup or program download.
+
+A local program does not necessarily make the first load fully offline:
+the existing runtime policy may fetch required runtime metadata from PAW and
+download the shared base model. Pass `offline=True` or set `PAW_OFFLINE=1`
+to prohibit all network access. Historical `PAW\x02` tensor containers,
+including output from the legacy `convert_peft_to_paw` module, are not supported
+by this loader; it does not convert PEFT tensors to GGUF.
+
+Only `paw.function` gains local-file inputs. `prepare_program` and
+`is_offline_ready` continue to accept Hub program references.
+
 ### Advanced: adapter-free base interpreter
 
 Pass explicit `None` plus an interpreter to run the supported base GGUF without a compiled PAW program:
@@ -155,11 +196,24 @@ Compiles a natural language spec on the server. Returns a `Program` object.
 |-----------|-------------|
 | `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. |
+| `status` | Status returned by the server, normally `"ready"` on success. HTTP errors raise `APIError` instead of returning a failed `Program`. |
 | `compiler_snapshot` | Exact compiler version used. |
 | `timings` | Timing metadata from the server. |
 | `error` | Error message when compilation fails. |
 
+### Compile timeouts
+
+Synchronous `compile` uses `httpx.Timeout(120.0, read=2400.0)`: connect, write,
+and pool waits remain 120 seconds; the read timeout is 2,400 seconds. This
+allows for the origin's 1,900-second provider wait plus up to 330 seconds of
+artifact finalization. It is a timeout while waiting for response data, **not a
+40-minute total deadline or guarantee**; upstream services may fail earlier.
+The same setting applies to the compile step of `compile_and_load`.
+
+Async submission retains a 30-second timeout. Precheck, status polling, and
+cancellation each retain a 10-second timeout. For long finetunes, prefer the
+explicit async workflow below so you retain a job ID for later status checks.
+
 ## Long-running compile jobs
 
 The asynchronous compile endpoint is available through both `PAWClient` and top-level helpers:
@@ -183,6 +237,37 @@ Status and cancellation requests must use the same authenticated account as
 submission. Anonymous jobs are bound to the validated client IP that submitted
 them.
 
+### Compile API errors
+
+`compile`, `precheck_compile`, `compile_async`, `get_compile_status`, and
+`cancel_compile` raise `paw.APIError` for HTTP 4xx/5xx responses. It is a subclass
+of `httpx.HTTPStatusError`, so existing handlers continue to work. When supplied
+by the server, `code`, `message`, and `request_id` are available as attributes
+and included in the exception text. Missing fields are `None`; the original
+`request` and `response` remain available, including response headers and body.
+
+```python
+try:
+    job = paw.compile_async(SPEC, compiler="paw-ft-bs48")
+except paw.APIError as error:
+    print(error.code, error.message, error.request_id)
+    # error.response.status_code and error.response.headers are unchanged.
+    raise
+```
+
+For example, a `durable_queue_unavailable` 503 reports that durable Redis must
+be healthy before async compilation can proceed. That rejection occurs before
+the job is accepted; the caller can submit again after service recovery.
+The SDK does not automatically retry compilation requests: other failures may
+occur after a job has already been recorded. Invalid/non-JSON error bodies
+retain the ordinary HTTP error description rather than displaying raw content.
+
+Transport errors such as `httpx.ReadTimeout` propagate unchanged, rather than
+becoming `APIError`. A timeout does not prove the server rejected or cancelled
+the work, so the SDK does not automatically resubmit it. Both `paw.compile`
+and `paw.compile_and_load` propagate these errors; `compile_and_load` does not
+attempt to load a function when compilation raises.
+
 ## `paw.compile_and_load`
 
 ```python

{programasweights-0.4.4 → programasweights-0.4.5}/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.4"
+    __version__ = "0.4.5"
 
 from ._output import ProgressCallback, ProgressEvent, report_progress
 from .cache import CachedProgram
@@ -39,6 +39,7 @@ from .client import (
     Program,
 )
 from .config import get_api_url, get_api_key, set_api_key
+from .errors import APIError
 
 
 def compile(
@@ -400,18 +401,22 @@ def function(
 ):
     """Load a compiled program, or explicitly load a bare base interpreter.
 
-    Downloads the .paw bundle and base model GGUF on first use.
-    Subsequent calls use the local cache.
+    Hub references download the .paw bundle on first use; local paths supply
+    it directly. Required runtime metadata and base models may still download
+    unless offline mode is enabled. Subsequent calls reuse validated caches.
 
     Args:
         program_id: Program ID (str), slug (``da03/my-program``), pinned version
-            (``da03/my-program@v3``), or a ``Program`` object from compile().
+            (``da03/my-program@v3``), a ``Program`` object from compile(), or a
+            local GGUF-based .paw bundle. PathLike objects and explicit path
+            strings (including strings ending in .paw) select local files.
         n_ctx: Context window size for llama.cpp.
         n_gpu_layers: GPU layers (-1 = all GPU, 0 = CPU only). Defaults to -1
             (auto-uses Metal/CUDA if available, safe fallback to CPU).
             Set ``PAW_GPU_LAYERS=0`` env var to force CPU-only.
         verbose: Print llama.cpp debug output.
-        offline: Skip server check for slug resolution and use local cache only.
+        offline: Prohibit network access. Local bundles may be imported, but
+            their runtime and base model must already be available locally.
             Also set via ``PAW_OFFLINE=1`` env var.
         interpreter: Advanced adapter-free mode. This is only valid when
             ``program_id`` is explicitly ``None``. Initially supported values
@@ -427,6 +432,8 @@ def function(
 
         >>> fn = paw.function("da03/my-program@v2")  # pinned version
 
+        >>> fn = paw.function("./classifier.paw")  # local bundle
+
         >>> base = paw.function(None, interpreter="gpt2")
     """
     import os
@@ -452,7 +459,12 @@ def function(
             offline=offline,
         )
 
-    program_reference = _coerce_program_reference(program_id)
+    from ._program_reference import local_program_path
+
+    local_path = local_program_path(program_id)
+    program_reference = (
+        _coerce_program_reference(program_id) if local_path is None else None
+    )
     if program_reference == "":
         raise ValueError(
             "program_id cannot be an empty string; pass explicit None with "
@@ -464,25 +476,35 @@ def function(
             "program_id=None to request adapter-free base mode."
         )
 
-    from .runtime_llamacpp import PawFunction
+    if local_path is not None:
+        from .local_program import import_local_program
 
-    resolved_id = _resolve_program_id(program_reference, offline=offline)
-    if offline and not cache.has_valid_program_assets(resolved_id):
-        raise RuntimeError(
-            f"Program {resolved_id} is not fully cached; offline mode "
-            "prohibits program downloads."
-        )
-    if not cache.has_valid_program_assets(resolved_id):
-        from .client import PAWClient
+        # Validate explicit local input before importing the native runtime.
+        # A missing/corrupt file is never retried as a Hub ID or slug.
+        program_dir = import_local_program(local_path)
+        from .runtime_llamacpp import PawFunction
+    else:
+        # Preserve the existing Hub path's fail-fast dependency check before
+        # resolving slugs or downloading assets.
+        from .runtime_llamacpp import PawFunction
 
-        client = PAWClient(api_url=get_api_url(), api_key=get_api_key())
-        client.download_paw(resolved_id)
-    if not cache.has_valid_program_assets(resolved_id):
-        raise RuntimeError(
-            f"Program {resolved_id} is missing valid compiled assets."
-        )
+        resolved_id = _resolve_program_id(program_reference, offline=offline)
+        if offline and not cache.has_valid_program_assets(resolved_id):
+            raise RuntimeError(
+                f"Program {resolved_id} is not fully cached; offline mode "
+                "prohibits program downloads."
+            )
+        if not cache.has_valid_program_assets(resolved_id):
+            from .client import PAWClient
+
+            client = PAWClient(api_url=get_api_url(), api_key=get_api_key())
+            client.download_paw(resolved_id)
+        if not cache.has_valid_program_assets(resolved_id):
+            raise RuntimeError(
+                f"Program {resolved_id} is missing valid compiled assets."
+            )
+        program_dir = cache.get_program_dir(resolved_id)
 
-    program_dir = cache.get_program_dir(resolved_id)
     return PawFunction(
         program_dir,
         n_ctx=n_ctx,
@@ -616,6 +638,7 @@ def list_compilers() -> list[dict]:
 
 
 __all__ = [
+    "APIError",
     "CachedProgram",
     "CompileCancellation",
     "CompileJob",

programasweights-0.4.5/programasweights/_program_reference.py

@@ -0,0 +1,61 @@
+"""Deterministic local-file intent, independent of filesystem contents."""
+
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+
+
+_WINDOWS_DRIVE = re.compile(r"^[A-Za-z]:")
+_URI_SCHEME = re.compile(r"^[A-Za-z][A-Za-z0-9+.-]*:")
+
+
+def local_program_path(reference: object) -> Path | None:
+    """Return an explicit local path, or None for an ID/slug/Program.
+
+    Path-like objects always mean files. Strings select files by syntax, never
+    by existence; in particular, an ``owner/slug`` remains a Hub reference.
+    """
+    is_pathlike = isinstance(reference, os.PathLike)
+    if is_pathlike:
+        value = os.fspath(reference)
+        if not isinstance(value, str):
+            raise TypeError("Local program paths must be text, not bytes.")
+    elif isinstance(reference, str):
+        value = reference
+    else:
+        return None
+
+    if "\x00" in value:
+        raise ValueError("Program references cannot contain null bytes.")
+    windows_drive = bool(_WINDOWS_DRIVE.match(value))
+    if not is_pathlike and not windows_drive and _URI_SCHEME.match(value):
+        raise ValueError(
+            "Program URLs are not supported. Download the .paw bundle first "
+            "and pass its local path."
+        )
+
+    explicit_path = value.startswith(
+        ("./", "../", "/", "~/", "\\", ".\\", "..\\", "~\\")
+    )
+    if not (
+        is_pathlike or windows_drive or explicit_path
+        or value.lower().endswith(".paw")
+    ):
+        return None
+    if not value:
+        raise ValueError("Local program path cannot be empty.")
+
+    # A Windows-looking string must never be sent to the Hub on another OS.
+    # Path objects, however, explicitly name a native path and may contain
+    # characters that would have a different meaning on another platform.
+    windows_path = windows_drive or value.startswith(
+        ("\\", ".\\", "..\\", "~\\")
+    )
+    if not is_pathlike and os.name != "nt" and windows_path:
+        raise ValueError(
+            "This is a Windows filesystem path, which cannot be opened on "
+            "this platform. Pass a native local path instead."
+        )
+    return Path(value).expanduser()

{programasweights-0.4.4 → programasweights-0.4.5}/programasweights/client.py

@@ -21,6 +21,7 @@ import httpx
 
 from . import config
 from ._output import ProgressCallback, report_progress
+from .errors import raise_for_api_status
 
 MAX_PAW_ARCHIVE_BYTES = 256 * 1024 * 1024
 MAX_PAW_ARCHIVE_MEMBERS = 256
@@ -170,7 +171,7 @@ class PAWClient:
             Program with id, slug, status, and timings.
 
         Raises:
-            httpx.HTTPStatusError: On API errors (422 for validation, 429 for rate limit).
+            APIError: On API errors; also caught by httpx.HTTPStatusError.
         """
         body = self._compile_body(
             spec,
@@ -186,9 +187,12 @@ class PAWClient:
             f"{self._api_url}/api/v1/compile",
             json=body,
             headers=self._headers(),
-            timeout=120.0,
+            # Allow a long response wait (1900s provider + 330s finalization)
+            # without extending connect/write/pool timeouts beyond 120s.
+            # This is a read timeout, not a total deadline; prefer compile_async().
+            timeout=httpx.Timeout(120.0, read=2400.0),
         )
-        resp.raise_for_status()
+        raise_for_api_status(resp)
         data = resp.json()
 
         return Program(
@@ -221,7 +225,7 @@ class PAWClient:
             headers=self._headers(),
             timeout=10.0,
         )
-        resp.raise_for_status()
+        raise_for_api_status(resp)
         return cast(CompilePrecheck, resp.json())
 
     def compile_async(
@@ -260,7 +264,7 @@ class PAWClient:
             headers=self._headers(),
             timeout=30.0,
         )
-        resp.raise_for_status()
+        raise_for_api_status(resp)
         return cast(CompileJob, resp.json())
 
     def get_compile_status(self, job_id: str) -> CompileStatus:
@@ -270,7 +274,7 @@ class PAWClient:
             headers=self._headers(),
             timeout=10.0,
         )
-        resp.raise_for_status()
+        raise_for_api_status(resp)
         return cast(CompileStatus, resp.json())
 
     def cancel_compile(self, job_id: str) -> CompileCancellation:
@@ -283,7 +287,7 @@ class PAWClient:
             headers=self._headers(),
             timeout=10.0,
         )
-        resp.raise_for_status()
+        raise_for_api_status(resp)
         return cast(CompileCancellation, resp.json())
 
     def resolve_slug(self, slug: str) -> str:

{programasweights-0.4.4 → programasweights-0.4.5}/programasweights/convert_peft_to_paw.py

@@ -1,15 +1,11 @@
 """
-Convert a PEFT/LoRA checkpoint to .paw format.
+Legacy PEFT/LoRA converter for the PAW-v2 tensor format.
 
-Supports the standard PEFT workflow:
-  1. Train with HuggingFace PEFT library
-  2. Save adapter: model.save_pretrained("my_adapter/")
-  3. Convert to .paw: paw.from_peft("my_adapter/", "output.paw", spec="...")
-
-The resulting .paw file can be:
-  - Shared on the Program Hub
-  - Loaded with paw.function("output.paw")
-  - Distributed as a single file
+This module writes the historical PAW\\x02 tensor container, not the current
+GGUF ZIP .paw bundle. Its output is NOT supported by the modern public
+paw.function local-file loader. It does not convert PEFT weights to GGUF, and
+from_peft is not exported as paw.from_peft. Use a current hosted-compile bundle
+for the public loader; this legacy converter is retained for older workflows.
 """
 
 import json
@@ -34,7 +30,9 @@ def from_peft(
     interpreter_model: Optional[str] = None,
 ) -> str:
     """
-    Convert a PEFT/LoRA adapter to .paw format.
+    Convert a PEFT/LoRA adapter to the legacy, non-GGUF .paw tensor format.
+
+    The output cannot be loaded by the modern public paw.function API.
     
     Args:
         adapter_path: Path to PEFT adapter directory (contains adapter_config.json + adapter_model.safetensors)
@@ -51,7 +49,7 @@ def from_peft(
         Path to saved .paw file
     
     Example:
-        >>> import programasweights as paw
+        >>> from programasweights.convert_peft_to_paw import from_peft
         >>>
         >>> # After training with PEFT:
         >>> # from peft import get_peft_model, LoraConfig
@@ -59,8 +57,8 @@ def from_peft(
         >>> # trainer.train()
         >>> # model.save_pretrained("my_adapter/")
         >>>
-        >>> # Convert to .paw:
-        >>> paw.from_peft(
+        >>> # Convert for a legacy tensor-format consumer, not paw.function:
+        >>> from_peft(
         ...     "my_adapter/",
         ...     "sentiment.paw",
         ...     spec="Classify text sentiment as positive, negative, or neutral",