wavespeed 1.0.13__tar.gz → 2.0.0__tar.gz

wavespeed-2.0.0/.github/workflows/tests.yml

@@ -0,0 +1,39 @@
+name: tests
+
+on:
+  pull_request:
+    branches:
+      - main
+  push:
+    branches:
+      - main
+    tags:
+      - "v[0-9]+*"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  # The package advertises Python >=3.8, so every advertised version is tested.
+  # PEP 604 syntax is only legal at runtime on 3.10+, which is why the modules
+  # carrying annotations import `from __future__ import annotations`; this
+  # matrix is what keeps that from silently regressing.
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: python -m pip install --upgrade pip
+      - run: pip install -e . pytest
+      - run: python -c "import wavespeed; print(wavespeed.__version__)"
+      - run: python -m pytest -q

wavespeed-2.0.0/CHANGELOG.md

@@ -0,0 +1,53 @@
+# Changelog
+
+All notable changes to this project are documented here.
+
+Versions are derived from Git tags via `setuptools_scm` — see [VERSIONING.md](VERSIONING.md).
+
+## 2.0.0
+
+### Removed — BREAKING
+
+**The serverless worker implementation has been removed from the SDK.**
+
+WaveSpeed no longer offers serverless as an external product, so shipping a serverless worker in
+the public SDK was misleading: it advertised a capability customers cannot buy. Everything below is
+gone as of 2.0.0 and will not be restored.
+
+- `wavespeed.serverless` — the entire package, including `serverless.start()`, the job scaler, the
+  handler-type dispatcher, the worker HTTP layer, the FastAPI local dev server, local test mode,
+  worker/job state tracking, heartbeat and progress reporting, the S3 (`boto3`) upload helpers, and
+  `wavespeed.serverless.utils.validate`.
+- `wavespeed.config.serverless` — the serverless config namespace and its import-time environment
+  auto-detection (`RUNPOD_*` and `WAVERLESS_*` variables are no longer read by this package).
+- `images/` — the `test_worker` Docker image and its build/push scripts, which existed only to
+  build and exercise the worker.
+
+Anyone building workers against this package should pin `wavespeed<2` and plan to migrate.
+
+### Fixed
+
+- **Python 3.8 and 3.9 support is now real rather than aspirational.** `api/__init__.py` carried a
+  module-level PEP 604 annotation (`Client | None`) with no `__future__` import, so the package
+  could not be imported on 3.8 or 3.9 despite `requires-python = ">=3.8"`. CI now runs the suite on
+  3.8 through 3.12 so the claim stays honest.
+- `typing_extensions` is now a declared dependency. It was imported at module scope but only
+  reached the environment transitively through `boto3`/`aiohttp` — removing those would have
+  produced an `ImportError` on a clean install.
+
+### Changed
+
+- Dependencies trimmed to what the API client actually needs. `aiohttp`, `aiohttp[speedups]`,
+  `aiohttp-retry`, and `boto3` are no longer installed; `typing_extensions` is now declared
+  explicitly (it was already imported by `wavespeed._config_module`).
+- README and CLAUDE.md rewritten to describe an API-client-only SDK.
+
+### Unchanged
+
+The API client surface is untouched: `wavespeed.run`, `wavespeed.run_no_throw`,
+`wavespeed.get_result`, `wavespeed.upload`, `wavespeed.Client`, `wavespeed.config.api`, and the
+channel-attribution request headers all behave exactly as they did in 1.0.x.
+
+## 1.0.14 and earlier
+
+See the Git history and GitHub releases.

wavespeed-2.0.0/CLAUDE.md

@@ -0,0 +1,57 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+WaveSpeed Python SDK - Official Python SDK for the WaveSpeedAI inference platform. It is an API
+client only: it submits jobs to the hosted WaveSpeed API, polls for results, and uploads files.
+
+> As of v2.0.0 the SDK no longer ships a serverless worker implementation. WaveSpeed does not offer
+> serverless as an external product, so that code was removed rather than left in the public SDK.
+
+## Commands
+
+### Testing
+```bash
+# Run all tests
+python -m pytest
+
+# Run a single test file
+python -m pytest tests/test_api.py
+
+# Run a specific test
+python -m pytest tests/test_api.py::TestClient::test_run_success -v
+```
+
+### Linting
+```bash
+pre-commit run --all-files
+```
+
+### Local Development
+```bash
+# Install in editable mode
+pip install -e .
+```
+
+## Architecture
+
+### API client (`src/wavespeed/api/`)
+
+- `client.py` - `Client`, the only transport. Synchronous, built on `requests`. Handles job
+  submission, result polling, terminal-status handling, file upload, and the channel-attribution
+  headers (`X-Client-Name`, etc.).
+- `__init__.py` - module-level convenience wrappers over a lazily created default `Client`:
+  `run`, `run_no_throw`, `get_result`, `upload`.
+
+`run` raises on failure; `run_no_throw` returns `{"status", "outputs", "task_id", "error"}` instead,
+mirroring the JavaScript SDK. `get_result` recovers a task whose local wait timed out.
+
+### Configuration (`src/wavespeed/config.py`)
+
+A single `api` config class, installed as a config module by `_config_module.py` (the PyTorch-style
+`install_config_module` shim). This gives `wavespeed.config.patch(...)` as a context manager /
+decorator for tests. `Client` reads its defaults from `wavespeed.config.api`.
+
+`WAVESPEED_API_KEY` seeds `config.api.api_key` at import time.

{wavespeed-1.0.13/src/wavespeed.egg-info → wavespeed-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavespeed
-Version: 1.0.13
+Version: 2.0.0
 Summary: WaveSpeed Python Client — Official Python SDK for the WaveSpeed inference platform
 Author-email: WaveSpeedAI <support@wavespeed.ai>
 License: MIT
@@ -19,10 +19,8 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aiohttp[speedups]>=3.9.3
-Requires-Dist: aiohttp-retry>=2.8.3
 Requires-Dist: requests>=2.25.0
-Requires-Dist: boto3>=1.26.165
+Requires-Dist: typing_extensions>=4.5.0
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Dynamic: license-file
@@ -142,106 +140,8 @@ url = wavespeed.upload("/path/to/image.png")
 print(url)
 ```
 
-## Serverless Worker
-
-Build serverless workers for the WaveSpeed platform.
-
-### Basic Handler
-
-```python
-import wavespeed.serverless as serverless
-
-def handler(job):
-    job_input = job["input"]
-    result = job_input.get("prompt", "").upper()
-    return {"output": result}
-
-serverless.start({"handler": handler})
-```
-
-### Async Handler
-
-```python
-import wavespeed.serverless as serverless
-
-async def handler(job):
-    job_input = job["input"]
-    result = await process_async(job_input)
-    return {"output": result}
-
-serverless.start({"handler": handler})
-```
-
-### Generator Handler (Streaming)
-
-```python
-import wavespeed.serverless as serverless
-
-def handler(job):
-    for i in range(10):
-        yield {"progress": i, "partial": f"chunk-{i}"}
-
-serverless.start({"handler": handler})
-```
-
-### Input Validation
-
-```python
-from wavespeed.serverless.utils import validate
-
-INPUT_SCHEMA = {
-    "prompt": {"type": str, "required": True},
-    "max_tokens": {"type": int, "required": False, "default": 100},
-    "temperature": {
-        "type": float,
-        "required": False,
-        "default": 0.7,
-        "constraints": lambda x: 0 <= x <= 2,
-    },
-}
-
-def handler(job):
-    result = validate(job["input"], INPUT_SCHEMA)
-    if "errors" in result:
-        return {"error": result["errors"]}
-
-    validated = result["validated_input"]
-    # process with validated input...
-    return {"output": "done"}
-```
-
-### Concurrent Execution
-
-Enable concurrent job processing with `concurrency_modifier`:
-
-```python
-import wavespeed.serverless as serverless
-
-def handler(job):
-    return {"output": job["input"]["data"]}
-
-def concurrency_modifier(current_concurrency):
-    return 2  # Process 2 jobs concurrently
-
-serverless.start({
-    "handler": handler,
-    "concurrency_modifier": concurrency_modifier
-})
-```
-
 ## Local Development
 
-### Test with JSON Input
-
-```bash
-# Using CLI argument
-python handler.py --test_input '{"input": {"prompt": "hello"}}'
-
-# Using test_input.json file (auto-detected)
-echo '{"input": {"prompt": "hello"}}' > test_input.json
-python handler.py
-```
-
 ### Running Tests
 
 ```bash
@@ -255,54 +155,13 @@ python -m pytest tests/test_api.py
 python -m pytest tests/test_api.py::TestClient::test_run_success -v
 ```
 
-### FastAPI Development Server
-
-```bash
-python handler.py --waverless_serve_api --waverless_api_port 8000
-```
-
-Then use the interactive Swagger UI at `http://localhost:8000/` or make requests:
-
-```bash
-# Synchronous execution
-curl -X POST http://localhost:8000/runsync \
-  -H "Content-Type: application/json" \
-  -d '{"input": {"prompt": "hello"}}'
-
-# Async execution
-curl -X POST http://localhost:8000/run \
-  -H "Content-Type: application/json" \
-  -d '{"input": {"prompt": "hello"}}'
-```
-
-## CLI Options
-
-| Option | Description |
-|--------|-------------|
-| `--test_input JSON` | Run locally with JSON test input |
-| `--waverless_serve_api` | Start FastAPI development server |
-| `--waverless_api_host HOST` | API server host (default: localhost) |
-| `--waverless_api_port PORT` | API server port (default: 8000) |
-| `--waverless_log_level LEVEL` | Log level (DEBUG, INFO, WARN, ERROR) |
-
 ## Environment Variables
 
-### API Client
-
 | Variable | Description |
 |----------|-------------|
 | `WAVESPEED_API_KEY` | WaveSpeed API key |
 | `WAVESPEED_CLIENT_NAME` | Channel-attribution name sent as the `X-Client-Name` header (overrides the `client_name` parameter; defaults to `wavespeed-python`) |
 
-### Serverless Worker
-
-| Variable | Description |
-|----------|-------------|
-| `WAVERLESS_POD_ID` | Worker/pod identifier |
-| `WAVERLESS_API_KEY` | API authentication key |
-| `WAVERLESS_WEBHOOK_GET_JOB` | Job fetch endpoint |
-| `WAVERLESS_WEBHOOK_POST_OUTPUT` | Result submission endpoint |
-
 ## License
 
 MIT

{wavespeed-1.0.13 → wavespeed-2.0.0}/README.md

@@ -113,106 +113,8 @@ url = wavespeed.upload("/path/to/image.png")
 print(url)
 ```
 
-## Serverless Worker
-
-Build serverless workers for the WaveSpeed platform.
-
-### Basic Handler
-
-```python
-import wavespeed.serverless as serverless
-
-def handler(job):
-    job_input = job["input"]
-    result = job_input.get("prompt", "").upper()
-    return {"output": result}
-
-serverless.start({"handler": handler})
-```
-
-### Async Handler
-
-```python
-import wavespeed.serverless as serverless
-
-async def handler(job):
-    job_input = job["input"]
-    result = await process_async(job_input)
-    return {"output": result}
-
-serverless.start({"handler": handler})
-```
-
-### Generator Handler (Streaming)
-
-```python
-import wavespeed.serverless as serverless
-
-def handler(job):
-    for i in range(10):
-        yield {"progress": i, "partial": f"chunk-{i}"}
-
-serverless.start({"handler": handler})
-```
-
-### Input Validation
-
-```python
-from wavespeed.serverless.utils import validate
-
-INPUT_SCHEMA = {
-    "prompt": {"type": str, "required": True},
-    "max_tokens": {"type": int, "required": False, "default": 100},
-    "temperature": {
-        "type": float,
-        "required": False,
-        "default": 0.7,
-        "constraints": lambda x: 0 <= x <= 2,
-    },
-}
-
-def handler(job):
-    result = validate(job["input"], INPUT_SCHEMA)
-    if "errors" in result:
-        return {"error": result["errors"]}
-
-    validated = result["validated_input"]
-    # process with validated input...
-    return {"output": "done"}
-```
-
-### Concurrent Execution
-
-Enable concurrent job processing with `concurrency_modifier`:
-
-```python
-import wavespeed.serverless as serverless
-
-def handler(job):
-    return {"output": job["input"]["data"]}
-
-def concurrency_modifier(current_concurrency):
-    return 2  # Process 2 jobs concurrently
-
-serverless.start({
-    "handler": handler,
-    "concurrency_modifier": concurrency_modifier
-})
-```
-
 ## Local Development
 
-### Test with JSON Input
-
-```bash
-# Using CLI argument
-python handler.py --test_input '{"input": {"prompt": "hello"}}'
-
-# Using test_input.json file (auto-detected)
-echo '{"input": {"prompt": "hello"}}' > test_input.json
-python handler.py
-```
-
 ### Running Tests
 
 ```bash
@@ -226,54 +128,13 @@ python -m pytest tests/test_api.py
 python -m pytest tests/test_api.py::TestClient::test_run_success -v
 ```
 
-### FastAPI Development Server
-
-```bash
-python handler.py --waverless_serve_api --waverless_api_port 8000
-```
-
-Then use the interactive Swagger UI at `http://localhost:8000/` or make requests:
-
-```bash
-# Synchronous execution
-curl -X POST http://localhost:8000/runsync \
-  -H "Content-Type: application/json" \
-  -d '{"input": {"prompt": "hello"}}'
-
-# Async execution
-curl -X POST http://localhost:8000/run \
-  -H "Content-Type: application/json" \
-  -d '{"input": {"prompt": "hello"}}'
-```
-
-## CLI Options
-
-| Option | Description |
-|--------|-------------|
-| `--test_input JSON` | Run locally with JSON test input |
-| `--waverless_serve_api` | Start FastAPI development server |
-| `--waverless_api_host HOST` | API server host (default: localhost) |
-| `--waverless_api_port PORT` | API server port (default: 8000) |
-| `--waverless_log_level LEVEL` | Log level (DEBUG, INFO, WARN, ERROR) |
-
 ## Environment Variables
 
-### API Client
-
 | Variable | Description |
 |----------|-------------|
 | `WAVESPEED_API_KEY` | WaveSpeed API key |
 | `WAVESPEED_CLIENT_NAME` | Channel-attribution name sent as the `X-Client-Name` header (overrides the `client_name` parameter; defaults to `wavespeed-python`) |
 
-### Serverless Worker
-
-| Variable | Description |
-|----------|-------------|
-| `WAVERLESS_POD_ID` | Worker/pod identifier |
-| `WAVERLESS_API_KEY` | API authentication key |
-| `WAVERLESS_WEBHOOK_GET_JOB` | Job fetch endpoint |
-| `WAVERLESS_WEBHOOK_POST_OUTPUT` | Result submission endpoint |
-
 ## License
 
 MIT

{wavespeed-1.0.13 → wavespeed-2.0.0}/pyproject.toml

@@ -25,10 +25,8 @@ classifiers = [
 dynamic = ["version"]
 
 dependencies = [
-    "aiohttp[speedups]>=3.9.3",
-    "aiohttp-retry>=2.8.3",
     "requests>=2.25.0",
-    "boto3>=1.26.165",
+    "typing_extensions>=4.5.0",
 ]
 
 [project.urls]

{wavespeed-1.0.13 → wavespeed-2.0.0}/src/wavespeed/__init__.py

@@ -1,9 +1,9 @@
 """
 WaveSpeedAI Python Client — Official Python SDK for WaveSpeedAI inference platform.
 
-This library provides a clean, unified, and high-performance API and serverless
-integration layer for your applications. Effortlessly connect to all
-WaveSpeedAI models and inference services with zero infrastructure overhead.
+This library provides a clean, unified, and high-performance API client for
+your applications. Effortlessly connect to all WaveSpeedAI models and
+inference services with zero infrastructure overhead.
 
 Example usage:
     import wavespeed
@@ -21,10 +21,10 @@ except ImportError:
     # Version file doesn't exist yet (e.g., during initial development)
     __version__ = "0.0.0.dev0"
 
-# Import config to auto-detect and load serverless environment
+# Import config so `wavespeed.config` is available after `import wavespeed`
 from wavespeed import config  # noqa: F401
 
 # Import API client
-from wavespeed.api import Client, run, run_no_throw, upload
+from wavespeed.api import Client, get_result, run, run_no_throw, upload
 
-__all__ = ["__version__", "Client", "run", "run_no_throw", "upload"]
+__all__ = ["__version__", "Client", "get_result", "run", "run_no_throw", "upload"]

{wavespeed-1.0.13 → wavespeed-2.0.0}/src/wavespeed/_version.py

@@ -1,2 +1,2 @@
 # This file is automatically generated by setuptools_scm
-__version__ = "1.0.13"
+__version__ = "2.0.0"

{wavespeed-1.0.13 → wavespeed-2.0.0}/src/wavespeed/api/__init__.py

@@ -17,11 +17,13 @@ Example usage:
     print(url)  # URL of the uploaded file
 """
 
+from __future__ import annotations
+
 from typing import BinaryIO
 
 from wavespeed.api.client import Client
 
-__all__ = ["Client", "run", "run_no_throw", "upload"]
+__all__ = ["Client", "get_result", "run", "run_no_throw", "upload"]
 
 # Default client instance
 _default_client: Client | None = None
@@ -96,6 +98,28 @@ def run(
     )
 
 
+def get_result(
+    request_id: str,
+    *,
+    timeout: float | None = None,
+    api_key: str | None = None,
+) -> dict:
+    """Fetch a prediction's current state by id.
+
+    Recovers a task whose local wait timed out — it keeps running server-side.
+
+    Args:
+        request_id: The prediction request ID.
+        timeout: Request timeout in seconds.
+        api_key: Override the API key for this call.
+
+    Returns:
+        Full API response, including ``data.status`` and ``data.outputs``.
+    """
+    client = Client(api_key=api_key) if api_key else _get_default_client()
+    return client.get_result(request_id, timeout=timeout)
+
+
 def run_no_throw(
     model: str,
     input: dict | None = None,

{wavespeed-1.0.13 → wavespeed-2.0.0}/src/wavespeed/api/client.py

@@ -195,6 +195,26 @@ class Client:
 
         return request_id, None
 
+    def get_result(
+        self, request_id: str, timeout: float | None = None
+    ) -> dict[str, Any]:
+        """Fetch a prediction's current state by id.
+
+        Useful for recovering a task whose local wait timed out: the task keeps
+        running server-side, and this returns whatever state it has reached.
+
+        Args:
+            request_id: The prediction request ID.
+            timeout: Request timeout in seconds.
+
+        Returns:
+            Full API response, including ``data.status`` and ``data.outputs``.
+
+        Raises:
+            RuntimeError: If fetching the result fails after retries.
+        """
+        return self._get_result(request_id, timeout=timeout)
+
     def _get_result(
         self, request_id: str, timeout: float | None = None
     ) -> dict[str, Any]:

wavespeed-2.0.0/src/wavespeed/config.py

@@ -0,0 +1,42 @@
+"""Configuration module for WaveSpeed SDK."""
+
+import os
+import sys
+from typing import Optional
+
+from ._config_module import install_config_module
+
+
+_save_config_ignore = {
+    # workaround: "Can't pickle <function ...>"
+}
+
+
+class api:
+    """API client configuration options."""
+
+    # Authentication
+    api_key: Optional[str] = os.environ.get("WAVESPEED_API_KEY")
+
+    # API base URL
+    base_url: str = "https://api.wavespeed.ai"
+
+    # Connection timeout in seconds
+    connection_timeout: float = 10.0
+
+    # Total API call timeout in seconds
+    timeout: float = 36000.0
+
+    # Maximum number of retries for the entire operation (task-level retries)
+    max_retries: int = 0
+
+    # Maximum retries for idempotent result-query GET requests. Submission
+    # POSTs are intentionally sent at most once.
+    max_connection_retries: int = 5
+
+    # Base interval between retries in seconds (actual delay = retry_interval * attempt)
+    retry_interval: float = 1.0
+
+
+# adds patch, save_config, etc
+install_config_module(sys.modules[__name__])