wavespeed 2.0.3__tar.gz → 2.0.5__tar.gz

{wavespeed-2.0.3/src/wavespeed.egg-info → wavespeed-2.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavespeed
-Version: 2.0.3
+Version: 2.0.5
 Summary: WaveSpeed Python Client — Official Python SDK for the WaveSpeed inference platform
 Author-email: WaveSpeedAI <support@wavespeed.ai>
 License: MIT
@@ -94,12 +94,20 @@ output = client.run("wavespeed-ai/z-image/turbo", {"prompt": "Cat"})
 output = wavespeed.run(
     "wavespeed-ai/z-image/turbo",
     {"prompt": "Cat"},
-    timeout=36000.0,       # Max wait time in seconds (default: 36000.0)
+    timeout=None,          # Max wait time in seconds (default: None = wait until the task finishes)
     poll_interval=1.0,     # Status check interval (default: 1.0)
     enable_sync_mode=False, # Best-effort sync result attempt (default: False)
 )
 ```
 
+### Timeouts
+
+`timeout` is the overall wait for a task and defaults to no limit. Each HTTP
+request also has its own read timeout (time waiting for the server, not a
+total-transfer deadline): 30s for result queries, 60s for async submit and
+120s for uploads. Sync mode has no default read timeout. Set
+`wavespeed.config.api.read_timeout` to override all of these at once.
+
 ### Sync Mode
 
 Use `enable_sync_mode=True` to ask the API to wait for the result in the initial

{wavespeed-2.0.3 → wavespeed-2.0.5}/README.md

@@ -65,12 +65,20 @@ output = client.run("wavespeed-ai/z-image/turbo", {"prompt": "Cat"})
 output = wavespeed.run(
     "wavespeed-ai/z-image/turbo",
     {"prompt": "Cat"},
-    timeout=36000.0,       # Max wait time in seconds (default: 36000.0)
+    timeout=None,          # Max wait time in seconds (default: None = wait until the task finishes)
     poll_interval=1.0,     # Status check interval (default: 1.0)
     enable_sync_mode=False, # Best-effort sync result attempt (default: False)
 )
 ```
 
+### Timeouts
+
+`timeout` is the overall wait for a task and defaults to no limit. Each HTTP
+request also has its own read timeout (time waiting for the server, not a
+total-transfer deadline): 30s for result queries, 60s for async submit and
+120s for uploads. Sync mode has no default read timeout. Set
+`wavespeed.config.api.read_timeout` to override all of these at once.
+
 ### Sync Mode
 
 Use `enable_sync_mode=True` to ask the API to wait for the result in the initial

{wavespeed-2.0.3 → wavespeed-2.0.5}/src/wavespeed/_version.py

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

{wavespeed-2.0.3 → wavespeed-2.0.5}/src/wavespeed/api/__init__.py

@@ -173,7 +173,9 @@ def upload(file: str | BinaryIO, *, timeout: float | None = None) -> str:
 
     Args:
         file: File path string or file-like object to upload.
-        timeout: Total API call timeout in seconds.
+        timeout: Per-request read timeout in seconds (default:
+            ``api_config.read_timeout_upload``;
+            ``api_config.read_timeout`` overrides). Not a total-transfer deadline.
 
     Returns:
         URL of the uploaded file.

{wavespeed-2.0.3 → wavespeed-2.0.5}/src/wavespeed/api/client.py

@@ -44,6 +44,10 @@ class _SubmissionError(RuntimeError):
     """A task submission failed and must not be retried automatically."""
 
 
+class _TaskFailedError(RuntimeError):
+    """The task itself reported status ``failed``; a task-level re-run is allowed."""
+
+
 class Client:
     """WaveSpeed API client.
 
@@ -129,6 +133,23 @@ class Client:
             "X-Client-OS": _get_client_os(),
         }
 
+    @staticmethod
+    def _default_read_timeout(per_type_default: float) -> float:
+        """Return ``api_config.read_timeout`` if set, else the per-type default."""
+        override = api_config.read_timeout
+        return override if override is not None else per_type_default
+
+    def _request_timeouts(
+        self, read_timeout: float | None
+    ) -> tuple[float, float | None]:
+        """Build a (connect, read) timeouts tuple; read None means no limit."""
+        connect_timeout = (
+            min(self.connection_timeout, read_timeout)
+            if read_timeout
+            else self.connection_timeout
+        )
+        return (connect_timeout, read_timeout)
+
     def _submit(
         self,
         model: str,
@@ -142,7 +163,9 @@ class Client:
             model: Model identifier.
             input: Input parameters.
             enable_sync_mode: If True, wait for result in single request.
-            timeout: Request timeout in seconds.
+            timeout: Request read timeout in seconds. Default:
+                ``api_config.read_timeout_submit`` (async; ``api_config.read_timeout``
+                overrides) or ``api_config.timeout`` (sync mode; None = no limit).
 
         Returns:
             Tuple of (request_id, result). In async mode, result is None.
@@ -157,14 +180,14 @@ class Client:
         if enable_sync_mode:
             body["enable_sync_mode"] = True
 
-        request_timeout = timeout if timeout is not None else api_config.timeout
-        # Use connection timeout for connect, request_timeout for read
-        connect_timeout = (
-            min(self.connection_timeout, request_timeout)
-            if request_timeout
-            else self.connection_timeout
-        )
-        timeouts = (connect_timeout, request_timeout)
+        if timeout is not None:
+            request_timeout = timeout
+        elif enable_sync_mode:
+            # The sync-mode POST stays open until the task finishes.
+            request_timeout = api_config.timeout
+        else:
+            request_timeout = self._default_read_timeout(api_config.read_timeout_submit)
+        timeouts = self._request_timeouts(request_timeout)
 
         try:
             response = requests.post(
@@ -231,13 +254,12 @@ class Client:
             RuntimeError: If fetching result fails after retries.
         """
         url = f"{self.base_url}/api/v3/predictions/{request_id}/result"
-        request_timeout = timeout if timeout is not None else api_config.timeout
-        connect_timeout = (
-            min(self.connection_timeout, request_timeout)
-            if request_timeout
-            else self.connection_timeout
+        request_timeout = (
+            timeout
+            if timeout is not None
+            else self._default_read_timeout(api_config.read_timeout_get)
         )
-        timeouts = (connect_timeout, request_timeout)
+        timeouts = self._request_timeouts(request_timeout)
 
         last_error: Exception | None = None
 
@@ -302,7 +324,8 @@ class Client:
 
         Args:
             request_id: The prediction request ID.
-            timeout: Maximum wait time in seconds (None = no timeout).
+            timeout: Maximum wait time in seconds. None falls back to
+                ``api_config.timeout``, which defaults to None (no limit).
             poll_interval: Time between polls in seconds.
 
         Returns:
@@ -313,14 +336,15 @@ class Client:
             TimeoutError: If prediction times out.
         """
         start_time = time.time()
+        overall_timeout = timeout if timeout is not None else api_config.timeout
 
         while True:
             # Check timeout
-            if timeout is not None:
+            if overall_timeout is not None:
                 elapsed = time.time() - start_time
-                if elapsed >= timeout:
+                if elapsed >= overall_timeout:
                     raise TimeoutError(
-                        f"Prediction timed out after {timeout} seconds (task_id: {request_id})"
+                        f"Prediction timed out after {overall_timeout} seconds (task_id: {request_id})"
                     )
 
             result = self._get_result(request_id, timeout=timeout)
@@ -332,14 +356,13 @@ class Client:
 
             if status in ("failed", "cancelled", "timeout", "deleted"):
                 error = data.get("error") or "Unknown error"
-                raise RuntimeError(
-                    f"Prediction {status} (task_id: {request_id}): {error}"
-                )
+                error_cls = _TaskFailedError if status == "failed" else RuntimeError
+                raise error_cls(f"Prediction {status} (task_id: {request_id}): {error}")
 
             time.sleep(poll_interval)
 
     def _is_retryable_error(self, error: Exception) -> bool:
-        """Determine if an error is worth retrying at the task level.
+        """Determine if an error is worth re-running the task for.
 
         Args:
             error: The exception to check.
@@ -347,29 +370,17 @@ class Client:
         Returns:
             True if the error is retryable.
         """
-        # Submission errors are ambiguous: the server may already have created
-        # the task, so never turn them into another POST automatically.
-        if isinstance(error, _SubmissionError):
+        # Only a failure reported by the task itself is re-run, and only when it
+        # was a transient upstream error (HTTP 5xx / 429), as before: a
+        # deterministic failure such as a content-policy rejection would fail
+        # again. Submission errors are ambiguous (the task may already exist),
+        # and poll-side HTTP errors, poll retry exhaustion and client-side wait
+        # timeouts all happen after the task was created and may be charged, so
+        # none of them may turn into another POST.
+        if not isinstance(error, _TaskFailedError):
             return False
-
-        # Retry timeout and connection errors from result-query GETs.
-        if isinstance(
-            error,
-            (
-                requests.exceptions.Timeout,
-                requests.exceptions.ConnectionError,
-                TimeoutError,
-            ),
-        ):
-            return True
-
-        # Retry server errors (5xx) and rate limiting (429)
-        if isinstance(error, RuntimeError):
-            error_str = str(error)
-            if "HTTP 5" in error_str or "HTTP 429" in error_str:
-                return True
-
-        return False
+        error_str = str(error)
+        return "HTTP 5" in error_str or "HTTP 429" in error_str
 
     def _format_sync_mode_error(self, data: dict[str, Any]) -> str:
         """Build an actionable error for a non-completed sync-mode response."""
@@ -464,8 +475,10 @@ class Client:
     @staticmethod
     def _task_id_from_error(error: Exception) -> str:
         """Extract a task ID from an error message, mirroring the JS SDK."""
-        match = re.search(r"task_id:\s*([^)]+)", str(error))
-        return match.group(1).strip() if match else "unknown"
+        match = re.search(r"task_id:\s*([^)]+)|for task ([^\s:]+)", str(error))
+        if not match:
+            return "unknown"
+        return (match.group(1) or match.group(2)).strip()
 
     def run_no_throw(
         self,
@@ -581,7 +594,9 @@ class Client:
 
         Args:
             file: File path string or file-like object to upload.
-            timeout: Total API call timeout in seconds.
+            timeout: Per-request read timeout in seconds (default:
+                ``api_config.read_timeout_upload``;
+                ``api_config.read_timeout`` overrides). Not a total-transfer deadline.
 
         Returns:
             URL of the uploaded file.
@@ -604,8 +619,10 @@ class Client:
 
         ticket_url = f"{self.base_url}/api/v3/media/uploads"
         headers = self._get_headers()
-        timeout = timeout or api_config.timeout
-        request_timeout = (min(self.connection_timeout, timeout), timeout)
+        # Per-request read timeout (socket inactivity), not a transfer deadline.
+        request_timeout = self._request_timeouts(
+            timeout or self._default_read_timeout(api_config.read_timeout_upload)
+        )
 
         close_stream = False
         if isinstance(file, str):

wavespeed-2.0.5/src/wavespeed/config.py

@@ -0,0 +1,59 @@
+"""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
+
+    # Overall wait cap in seconds for a task. None (default) means no cap: the
+    # SDK waits until the task reaches a terminal status. An explicit
+    # ``timeout=`` argument takes priority over this value.
+    timeout: Optional[float] = None
+
+    # Per-request read timeout in seconds (time waiting for the server, not a
+    # total-transfer deadline). Bounds a half-open connection to one request
+    # instead of the whole task. Defaults by request type:
+    # result queries and other read-only GETs
+    read_timeout_get: float = 30.0
+    # async submit POST (a timeout here is an ambiguous outcome, so more headroom)
+    read_timeout_submit: float = 60.0
+    # upload ticket POST and file PUT
+    read_timeout_upload: float = 120.0
+    # Sync-mode submit stays open until the task finishes: no default limit.
+
+    # Optional single override applied to all of the above (not sync-mode
+    # submit). None keeps the per-type defaults.
+    read_timeout: Optional[float] = None
+
+    # 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__])

{wavespeed-2.0.3 → wavespeed-2.0.5/src/wavespeed.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavespeed
-Version: 2.0.3
+Version: 2.0.5
 Summary: WaveSpeed Python Client — Official Python SDK for the WaveSpeed inference platform
 Author-email: WaveSpeedAI <support@wavespeed.ai>
 License: MIT
@@ -94,12 +94,20 @@ output = client.run("wavespeed-ai/z-image/turbo", {"prompt": "Cat"})
 output = wavespeed.run(
     "wavespeed-ai/z-image/turbo",
     {"prompt": "Cat"},
-    timeout=36000.0,       # Max wait time in seconds (default: 36000.0)
+    timeout=None,          # Max wait time in seconds (default: None = wait until the task finishes)
     poll_interval=1.0,     # Status check interval (default: 1.0)
     enable_sync_mode=False, # Best-effort sync result attempt (default: False)
 )
 ```
 
+### Timeouts
+
+`timeout` is the overall wait for a task and defaults to no limit. Each HTTP
+request also has its own read timeout (time waiting for the server, not a
+total-transfer deadline): 30s for result queries, 60s for async submit and
+120s for uploads. Sync mode has no default read timeout. Set
+`wavespeed.config.api.read_timeout` to override all of these at once.
+
 ### Sync Mode
 
 Use `enable_sync_mode=True` to ask the API to wait for the result in the initial

{wavespeed-2.0.3 → wavespeed-2.0.5}/src/wavespeed.egg-info/SOURCES.txt

@@ -34,4 +34,5 @@ src/wavespeed/api/client.py
 tests/__init__.py
 tests/conftest.py
 tests/test_api.py
-tests/test_config.py
+tests/test_config.py
+tests/test_timeouts.py

{wavespeed-2.0.3 → wavespeed-2.0.5}/src/wavespeed.egg-info/scm_file_list.json

@@ -27,6 +27,7 @@
     "tests/__init__.py",
     "tests/conftest.py",
     "tests/test_api.py",
-    "tests/test_config.py"
+    "tests/test_config.py",
+    "tests/test_timeouts.py"
   ]
 }

wavespeed-2.0.5/src/wavespeed.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "2.0.5",
+  "distance": 0,
+  "node": "g7bcfc516a9110256323601831fd5f5bab8b923c1",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-17"
+}

{wavespeed-2.0.3 → wavespeed-2.0.5}/tests/test_api.py

@@ -149,6 +149,98 @@ class TestClient(unittest.TestCase):
 
         mock_post.assert_called_once()
 
+    @staticmethod
+    def _response(status_code, payload=None, text=""):
+        response = MagicMock()
+        response.status_code = status_code
+        response.text = text
+        response.json.return_value = payload
+        return response
+
+    @patch("wavespeed.api.client.time.sleep")
+    @patch("wavespeed.api.client.requests.get")
+    @patch("wavespeed.api.client.requests.post")
+    def test_task_retries_do_not_repost_after_poll_retry_exhaustion(
+        self, mock_post, mock_get, _mock_sleep
+    ):
+        """A poll that exhausts its GET retries must not create a second task."""
+        mock_post.return_value = self._response(200, {"data": {"id": "req-1"}})
+        mock_get.return_value = self._response(502, text="Bad Gateway")
+
+        client = Client(api_key="test-key", max_retries=2, max_connection_retries=1)
+        with self.assertRaises(RuntimeError) as ctx:
+            client.run("wavespeed-ai/z-image/turbo", {"prompt": "test"})
+
+        self.assertIn("req-1", str(ctx.exception))
+        self.assertIn("HTTP 502", str(ctx.exception))
+        self.assertEqual(mock_post.call_count, 1)
+        self.assertEqual(mock_get.call_count, 2)
+
+        result = client.run_no_throw("wavespeed-ai/z-image/turbo", {"prompt": "test"})
+        self.assertEqual(result["task_id"], "req-1")
+        self.assertEqual(mock_post.call_count, 2)  # one POST per run, never per poll
+
+    @patch("wavespeed.api.client.time.sleep")
+    @patch("wavespeed.api.client.requests.get")
+    @patch("wavespeed.api.client.requests.post")
+    def test_task_retries_do_not_repost_after_wait_timeout(
+        self, mock_post, mock_get, _mock_sleep
+    ):
+        """A client-side wait timeout leaves the task alive and must not re-POST."""
+        mock_post.return_value = self._response(200, {"data": {"id": "req-1"}})
+        mock_get.return_value = self._response(200, {"data": {"status": "processing"}})
+
+        client = Client(api_key="test-key", max_retries=2)
+        with self.assertRaises(TimeoutError) as ctx:
+            client.run("wavespeed-ai/z-image/turbo", {"prompt": "test"}, timeout=0)
+
+        self.assertIn("req-1", str(ctx.exception))
+        self.assertEqual(mock_post.call_count, 1)
+
+    @patch("wavespeed.api.client.time.sleep")
+    @patch("wavespeed.api.client.requests.get")
+    @patch("wavespeed.api.client.requests.post")
+    def test_task_retries_rerun_when_task_reports_failed(
+        self, mock_post, mock_get, _mock_sleep
+    ):
+        """A task that fails with a transient upstream error is re-run when max_retries > 0."""
+        mock_post.side_effect = [
+            self._response(200, {"data": {"id": "req-1"}}),
+            self._response(200, {"data": {"id": "req-2"}}),
+        ]
+        mock_get.side_effect = [
+            self._response(
+                200, {"data": {"status": "failed", "error": "HTTP 500 upstream error"}}
+            ),
+            self._response(200, {"data": {"status": "completed", "outputs": ["url"]}}),
+        ]
+
+        client = Client(api_key="test-key", max_retries=1)
+        result = client.run("wavespeed-ai/z-image/turbo", {"prompt": "test"})
+
+        self.assertEqual(result, {"outputs": ["url"]})
+        self.assertEqual(mock_post.call_count, 2)
+
+    @patch("wavespeed.api.client.time.sleep")
+    @patch("wavespeed.api.client.requests.get")
+    @patch("wavespeed.api.client.requests.post")
+    def test_task_retries_do_not_rerun_deterministic_failure(
+        self, mock_post, mock_get, _mock_sleep
+    ):
+        """A task that fails for a non-transient reason is not re-submitted."""
+        mock_post.side_effect = [self._response(200, {"data": {"id": "req-1"}})]
+        mock_get.side_effect = [
+            self._response(
+                200, {"data": {"status": "failed", "error": "content policy violation"}}
+            ),
+        ]
+
+        client = Client(api_key="test-key", max_retries=2)
+        with self.assertRaises(RuntimeError):
+            client.run("wavespeed-ai/z-image/turbo", {"prompt": "test"})
+
+        self.assertEqual(mock_post.call_count, 1)
+
     @patch("wavespeed.api.client.requests.get")
     def test_get_result_success(self, mock_get):
         """Test successful result retrieval."""
@@ -286,7 +378,11 @@ class TestModuleLevelRun(unittest.TestCase):
         mock_config.api_key = "config-key"
         mock_config.base_url = "https://api.wavespeed.ai"
         mock_config.connection_timeout = 10.0
-        mock_config.timeout = 36000.0
+        mock_config.timeout = None
+        mock_config.read_timeout = None
+        mock_config.read_timeout_get = 30.0
+        mock_config.read_timeout_submit = 60.0
+        mock_config.read_timeout_upload = 120.0
         mock_config.max_retries = 0
         mock_config.max_connection_retries = 5
         mock_config.retry_interval = 1.0
@@ -470,7 +566,11 @@ class TestRunNoThrow(unittest.TestCase):
         mock_config.api_key = "config-key"
         mock_config.base_url = "https://api.wavespeed.ai"
         mock_config.connection_timeout = 10.0
-        mock_config.timeout = 36000.0
+        mock_config.timeout = None
+        mock_config.read_timeout = None
+        mock_config.read_timeout_get = 30.0
+        mock_config.read_timeout_submit = 60.0
+        mock_config.read_timeout_upload = 120.0
         mock_config.max_retries = 0
         mock_config.max_connection_retries = 5
         mock_config.retry_interval = 1.0

{wavespeed-2.0.3 → wavespeed-2.0.5}/tests/test_config.py

@@ -26,7 +26,11 @@ class TestApiConfig(unittest.TestCase):
         """Test the shipped default values."""
         self.assertEqual(api.base_url, "https://api.wavespeed.ai")
         self.assertEqual(api.connection_timeout, 10.0)
-        self.assertEqual(api.timeout, 36000.0)
+        self.assertIsNone(api.timeout)
+        self.assertIsNone(api.read_timeout)
+        self.assertEqual(api.read_timeout_get, 30.0)
+        self.assertEqual(api.read_timeout_submit, 60.0)
+        self.assertEqual(api.read_timeout_upload, 120.0)
         self.assertEqual(api.max_retries, 0)
         self.assertEqual(api.max_connection_retries, 5)
         self.assertEqual(api.retry_interval, 1.0)

wavespeed-2.0.5/tests/test_timeouts.py

@@ -0,0 +1,235 @@
+"""Tests for the overall-wait cap vs. per-request read timeout split."""
+
+import http.server
+import io
+import threading
+import time
+import unittest
+from unittest.mock import MagicMock, patch
+
+import requests
+
+from wavespeed.api import Client
+
+
+def _resp(status=200, payload=None):
+    r = MagicMock()
+    r.status_code = status
+    r.text = ""
+    r.json.return_value = payload if payload is not None else {}
+    return r
+
+
+def _submit_ok():
+    return _resp(200, {"data": {"id": "t1"}})
+
+
+def _status(status, outputs=None):
+    return _resp(200, {"data": {"status": status, "outputs": outputs or []}})
+
+
+class FakeClock:
+    """time.time()/sleep() replacement: sleep advances the clock instantly."""
+
+    def __init__(self):
+        """Start at t=0."""
+        self.now = 0.0
+
+    def time(self):
+        """Return the fake now."""
+        return self.now
+
+    def sleep(self, seconds):
+        """Advance the fake clock."""
+        self.now += seconds
+
+
+@patch("wavespeed.api.client.time")
+@patch("wavespeed.api.client.requests.get")
+@patch("wavespeed.api.client.requests.post")
+class TestTimeouts(unittest.TestCase):
+    """Overall cap and per-request read timeouts."""
+
+    def setUp(self):
+        """Create a client."""
+        self.client = Client(api_key="k")
+
+    def _clock(self, mock_time):
+        clock = FakeClock()
+        mock_time.time.side_effect = clock.time
+        mock_time.sleep.side_effect = clock.sleep
+        return clock
+
+    def test_default_has_no_overall_cap(self, post, get, mock_time):
+        """Test default has no overall cap."""
+        clock = self._clock(mock_time)
+        post.return_value = _submit_ok()
+        # Polls at 1000s intervals: stays processing past 36000s, then completes.
+        get.side_effect = [_status("processing")] * 40 + [_status("completed", ["u"])]
+        out = self.client.run("m/x", {}, poll_interval=1000.0)
+        self.assertEqual(out, {"outputs": ["u"]})
+        self.assertEqual(get.call_count, 41)
+        self.assertGreater(clock.now, 36000.0)
+
+    def test_explicit_timeout_still_raises(self, post, get, mock_time):
+        """Test explicit timeout still raises."""
+        self._clock(mock_time)
+        post.return_value = _submit_ok()
+        get.return_value = _status("processing")
+        with self.assertRaises(TimeoutError):
+            self.client.run("m/x", {}, timeout=50.0, poll_interval=10.0)
+
+    def test_config_timeout_still_caps(self, post, get, mock_time):
+        """Test config timeout still caps."""
+        self._clock(mock_time)
+        post.return_value = _submit_ok()
+        get.return_value = _status("processing")
+        with patch("wavespeed.api.client.api_config.timeout", 50.0):
+            with self.assertRaises(TimeoutError):
+                self.client.run("m/x", {}, poll_interval=10.0)
+
+    def test_async_submit_and_get_use_read_timeout(self, post, get, mock_time):
+        """Test async submit and get use read timeout."""
+        self._clock(mock_time)
+        post.return_value = _submit_ok()
+        get.return_value = _status("completed")
+        self.client.run("m/x", {})
+        self.assertEqual(post.call_args.kwargs["timeout"], (10.0, 60.0))
+        self.assertEqual(get.call_args.kwargs["timeout"], (10.0, 30.0))
+
+    def test_override_applies_to_get_and_submit_not_sync(self, post, get, mock_time):
+        """Single read_timeout override covers GET and async submit, not sync."""
+        self._clock(mock_time)
+        post.return_value = _submit_ok()
+        get.return_value = _status("completed")
+        with patch("wavespeed.api.client.api_config.read_timeout", 7.0):
+            self.client.run("m/x", {})
+            self.assertEqual(post.call_args.kwargs["timeout"], (7.0, 7.0))
+            self.assertEqual(get.call_args.kwargs["timeout"], (7.0, 7.0))
+            post.return_value = _resp(200, {"data": {"status": "completed"}})
+            self.client.run("m/x", {}, enable_sync_mode=True)
+            self.assertEqual(post.call_args.kwargs["timeout"], (10.0, None))
+
+    def test_sync_submit_no_read_timeout_by_default(self, post, get, mock_time):
+        """Test sync submit no read timeout by default."""
+        post.return_value = _resp(200, {"data": {"status": "completed"}})
+        self.client.run("m/x", {}, enable_sync_mode=True)
+        self.assertEqual(post.call_args.kwargs["timeout"], (10.0, None))
+
+    def test_sync_submit_explicit_timeout(self, post, get, mock_time):
+        """Test sync submit explicit timeout."""
+        post.return_value = _resp(200, {"data": {"status": "completed"}})
+        self.client.run("m/x", {}, enable_sync_mode=True, timeout=300.0)
+        self.assertEqual(post.call_args.kwargs["timeout"], (10.0, 300.0))
+
+    def test_explicit_timeout_applies_to_requests(self, post, get, mock_time):
+        """Test explicit timeout applies to requests."""
+        self._clock(mock_time)
+        post.return_value = _submit_ok()
+        get.return_value = _status("completed")
+        self.client.run("m/x", {}, timeout=300.0)
+        self.assertEqual(post.call_args.kwargs["timeout"], (10.0, 300.0))
+        self.assertEqual(get.call_args.kwargs["timeout"], (10.0, 300.0))
+
+    def test_poll_retries_502_then_succeeds(self, post, get, mock_time):
+        """Test poll retries 502 then succeeds."""
+        self._clock(mock_time)
+        post.return_value = _submit_ok()
+        get.side_effect = [_resp(502), _status("completed", ["u"])]
+        out = self.client.run("m/x", {})
+        self.assertEqual(out, {"outputs": ["u"]})
+        self.assertEqual(get.call_count, 2)
+
+    def test_submit_timeout_is_not_retried(self, post, get, mock_time):
+        """Test submit timeout is not retried."""
+        post.side_effect = requests.exceptions.ReadTimeout()
+        with self.assertRaises(RuntimeError):
+            self.client.run("m/x", {})
+        self.assertEqual(post.call_count, 1)
+        get.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()
+
+
+def _ticket(url):
+    return _resp(
+        200,
+        {
+            "code": 200,
+            "data": {
+                "download_url": "https://example.com/f.bin",
+                "upload": {"method": "PUT", "url": url, "headers": {}},
+            },
+        },
+    )
+
+
+@patch("wavespeed.api.client.requests.put")
+@patch("wavespeed.api.client.requests.post")
+class TestUploadTimeouts(unittest.TestCase):
+    """upload() uses the per-request read timeout for every request."""
+
+    def test_default_read_timeout(self, post, put):
+        """Ticket POST and file PUT carry (connect, 120.0); override applies."""
+        post.return_value = _ticket("https://s.example.com/u")
+        put.return_value = _resp(200)
+        Client(api_key="k").upload(io.BytesIO(b"abc"))
+        self.assertEqual(post.call_args.kwargs["timeout"], (10.0, 120.0))
+        self.assertEqual(put.call_args.kwargs["timeout"], (10.0, 120.0))
+        with patch("wavespeed.api.client.api_config.read_timeout", 7.0):
+            Client(api_key="k").upload(io.BytesIO(b"abc"))
+        self.assertEqual(post.call_args.kwargs["timeout"], (7.0, 7.0))
+        self.assertEqual(put.call_args.kwargs["timeout"], (7.0, 7.0))
+
+    def test_explicit_timeout(self, post, put):
+        """An explicit timeout applies to both requests."""
+        post.return_value = _ticket("https://s.example.com/u")
+        put.return_value = _resp(200)
+        Client(api_key="k").upload(io.BytesIO(b"abc"), timeout=300.0)
+        self.assertEqual(post.call_args.kwargs["timeout"], (10.0, 300.0))
+        self.assertEqual(put.call_args.kwargs["timeout"], (10.0, 300.0))
+
+
+class TestSlowProgressingPut(unittest.TestCase):
+    """A slow but progressing PUT is not aborted by the read timeout."""
+
+    def test_slow_progressing_put_not_aborted(self):
+        """Body takes longer than read_timeout in total, gaps stay below it."""
+        received = []
+
+        class Handler(http.server.BaseHTTPRequestHandler):
+            def do_PUT(self):
+                remaining = int(self.headers["Content-Length"])
+                got = 0
+                while remaining:
+                    chunk = self.rfile.read(min(65536, remaining))
+                    got += len(chunk)
+                    remaining -= len(chunk)
+                    time.sleep(0.01)  # slow consumer, keeps making progress
+                received.append(got)
+                time.sleep(0.5)  # response headers arrive late but < timeout
+                self.send_response(200)
+                self.send_header("Content-Length", "0")
+                self.end_headers()
+
+            def log_message(self, *args):
+                pass
+
+        server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+        threading.Thread(target=server.serve_forever, daemon=True).start()
+        url = f"http://127.0.0.1:{server.server_address[1]}/u"
+        size = 24 * 1024 * 1024
+        try:
+            with patch("wavespeed.api.client.requests.post") as post:
+                post.return_value = _ticket(url)
+                with patch("wavespeed.api.client.api_config.read_timeout_upload", 2.0):
+                    start = time.time()
+                    out = Client(api_key="k").upload(io.BytesIO(b"x" * size))
+                    elapsed = time.time() - start
+        finally:
+            server.shutdown()
+        self.assertEqual(out, "https://example.com/f.bin")
+        self.assertEqual(received, [size])
+        self.assertGreater(elapsed, 2.0)  # total transfer exceeded read_timeout

wavespeed-2.0.3/src/wavespeed/config.py

@@ -1,42 +0,0 @@
-"""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__])

wavespeed-2.0.3/src/wavespeed.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "2.0.3",
-  "distance": 0,
-  "node": "g3e926667ae3ef93fc11dc277b6f09b081750ad7d",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-09-21"
-}