wavespeed 1.0.8__tar.gz → 1.0.9__tar.gz

{wavespeed-1.0.8 → wavespeed-1.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavespeed
-Version: 1.0.8
+Version: 1.0.9
 Summary: WaveSpeedAI Python Client — Official Python SDK for WaveSpeedAI inference platform
 Author-email: WaveSpeedAI <support@wavespeed.ai>
 License: MIT
@@ -93,13 +93,15 @@ output = wavespeed.run(
     {"prompt": "Cat"},
     timeout=36000.0,       # Max wait time in seconds (default: 36000.0)
     poll_interval=1.0,     # Status check interval (default: 1.0)
-    enable_sync_mode=False, # Single request mode, no polling (default: False)
+    enable_sync_mode=False, # Best-effort sync result attempt (default: False)
 )
 ```
 
 ### Sync Mode
 
-Use `enable_sync_mode=True` for a single request that waits for the result (no polling).
+Use `enable_sync_mode=True` to ask the API to wait for the result in the initial
+request. If the server-side sync wait times out, the SDK raises an error with
+the task ID/result URL; the task continues processing and can be queried later.
 
 > **Note:** Not all models support sync mode. Check the model documentation for availability.
 

{wavespeed-1.0.8 → wavespeed-1.0.9}/README.md

@@ -64,13 +64,15 @@ output = wavespeed.run(
     {"prompt": "Cat"},
     timeout=36000.0,       # Max wait time in seconds (default: 36000.0)
     poll_interval=1.0,     # Status check interval (default: 1.0)
-    enable_sync_mode=False, # Single request mode, no polling (default: False)
+    enable_sync_mode=False, # Best-effort sync result attempt (default: False)
 )
 ```
 
 ### Sync Mode
 
-Use `enable_sync_mode=True` for a single request that waits for the result (no polling).
+Use `enable_sync_mode=True` to ask the API to wait for the result in the initial
+request. If the server-side sync wait times out, the SDK raises an error with
+the task ID/result URL; the task continues processing and can be queried later.
 
 > **Note:** Not all models support sync mode. Check the model documentation for availability.
 

{wavespeed-1.0.8 → wavespeed-1.0.9}/src/wavespeed/_version.py

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

{wavespeed-1.0.8 → wavespeed-1.0.9}/src/wavespeed/api/__init__.py

@@ -51,7 +51,9 @@ def run(
         input: Input parameters for the model.
         timeout: Maximum time to wait for completion (None = no timeout).
         poll_interval: Interval between status checks in seconds.
-        enable_sync_mode: If True, use synchronous mode (single request).
+        enable_sync_mode: If True, use synchronous mode (best-effort single
+            request). If the server-side sync wait times out, an error is
+            raised with the task ID so the result can be queried later.
         max_retries: Maximum retries for this request (overrides default setting).
 
     Returns:

{wavespeed-1.0.8 → wavespeed-1.0.9}/src/wavespeed/api/client.py

@@ -9,6 +9,9 @@ import requests
 
 from wavespeed.config import api as api_config
 
+# HTTP status codes that are safe to retry
+_RETRYABLE_STATUS_CODES = {429, 500, 502, 503, 504}
+
 
 class Client:
     """WaveSpeed API client.
@@ -25,7 +28,7 @@ class Client:
         client = Client(api_key="your-api-key")
         output = client.run("wavespeed-ai/z-image/turbo", {"prompt": "Cat"})
 
-        # With sync mode (single request, waits for result)
+        # With sync mode (best-effort single request, waits for result)
         output = client.run("wavespeed-ai/z-image/turbo", {"prompt": "Cat"}, enable_sync_mode=True)
 
         # With retry
@@ -57,6 +60,18 @@ class Client:
             retry_interval if retry_interval is not None else api_config.retry_interval
         )
 
+    @staticmethod
+    def _is_retryable_status(status_code: int) -> bool:
+        """Check if an HTTP status code is retryable.
+
+        Args:
+            status_code: HTTP response status code.
+
+        Returns:
+            True if the status code indicates a transient error worth retrying.
+        """
+        return status_code in _RETRYABLE_STATUS_CODES
+
     def _get_headers(self) -> dict[str, str]:
         """Get request headers with authentication."""
         if not self.api_key:
@@ -106,6 +121,8 @@ class Client:
         )
         timeouts = (connect_timeout, request_timeout)
 
+        last_error: Exception | None = None
+
         for retry in range(self.max_connection_retries + 1):
             try:
                 response = requests.post(
@@ -113,6 +130,24 @@ class Client:
                 )
 
                 if response.status_code != 200:
+                    # Retry on transient server errors (5xx) and rate limiting (429)
+                    if self._is_retryable_status(response.status_code):
+                        last_error = RuntimeError(
+                            f"Failed to submit prediction: HTTP {response.status_code}: "
+                            f"{response.text}"
+                        )
+                        if retry < self.max_connection_retries:
+                            delay = self.retry_interval * (retry + 1)
+                            print(
+                                f"Server error (HTTP {response.status_code}) on attempt "
+                                f"{retry + 1}/{self.max_connection_retries + 1}, "
+                                f"retrying in {delay} seconds..."
+                            )
+                            time.sleep(delay)
+                            continue
+                        raise last_error
+
+                    # Non-retryable HTTP errors (4xx etc.) fail immediately
                     raise RuntimeError(
                         f"Failed to submit prediction: HTTP {response.status_code}: "
                         f"{response.text}"
@@ -133,6 +168,7 @@ class Client:
                 requests.exceptions.ConnectionError,
                 requests.exceptions.Timeout,
             ) as e:
+                last_error = e
                 print(
                     f"Connection error on attempt {retry + 1}/{self.max_connection_retries + 1}:"
                 )
@@ -171,6 +207,8 @@ class Client:
         )
         timeouts = (connect_timeout, request_timeout)
 
+        last_error: Exception | None = None
+
         for retry in range(self.max_connection_retries + 1):
             try:
                 response = requests.get(
@@ -178,6 +216,23 @@ class Client:
                 )
 
                 if response.status_code != 200:
+                    # Retry on transient server errors (5xx) and rate limiting (429)
+                    if self._is_retryable_status(response.status_code):
+                        last_error = RuntimeError(
+                            f"Failed to get result for task {request_id}: "
+                            f"HTTP {response.status_code}: {response.text}"
+                        )
+                        if retry < self.max_connection_retries:
+                            delay = self.retry_interval * (retry + 1)
+                            print(
+                                f"Server error (HTTP {response.status_code}) getting result "
+                                f"on attempt {retry + 1}/{self.max_connection_retries + 1}, "
+                                f"retrying in {delay} seconds..."
+                            )
+                            time.sleep(delay)
+                            continue
+                        raise last_error
+
                     raise RuntimeError(
                         f"Failed to get result for task {request_id}: "
                         f"HTTP {response.status_code}: {response.text}"
@@ -189,6 +244,7 @@ class Client:
                 requests.exceptions.ConnectionError,
                 requests.exceptions.Timeout,
             ) as e:
+                last_error = e
                 print(
                     f"Connection error getting result on attempt {retry + 1}/{self.max_connection_retries + 1}:"
                 )
@@ -261,7 +317,12 @@ class Client:
         """
         # Always retry timeout and connection errors
         if isinstance(
-            error, (requests.exceptions.Timeout, requests.exceptions.ConnectionError)
+            error,
+            (
+                requests.exceptions.Timeout,
+                requests.exceptions.ConnectionError,
+                TimeoutError,
+            ),
         ):
             return True
 
@@ -273,6 +334,25 @@ class Client:
 
         return False
 
+    @staticmethod
+    def _format_sync_mode_error(data: dict[str, Any]) -> str:
+        """Build an actionable error for a non-completed sync-mode response."""
+        request_id = data.get("id") or "unknown"
+        error = data.get("error") or "Unknown error"
+        urls = data.get("urls") or {}
+        result_url = urls.get("get") if isinstance(urls, dict) else None
+
+        is_sync_timeout = data.get("code") == 5004 or (
+            data.get("status") == "processing" and "Sync mode timed out" in error
+        )
+        if is_sync_timeout:
+            message = f"Sync mode timed out (task_id: {request_id}): {error}"
+            if result_url and result_url not in message:
+                message += f" Query the result later at: {result_url}"
+            return message
+
+        return f"Prediction failed (task_id: {request_id}): {error}"
+
     def run(
         self,
         model: str,
@@ -290,7 +370,9 @@ class Client:
             input: Input parameters for the model.
             timeout: Maximum time to wait for completion (None = no timeout).
             poll_interval: Interval between status checks in seconds.
-            enable_sync_mode: If True, use synchronous mode (single request).
+            enable_sync_mode: If True, use synchronous mode (best-effort single
+                request). If the server-side sync wait times out, the SDK raises
+                an error with the task ID so the result can be queried later.
             max_retries: Maximum task-level retries (overrides client setting).
 
         Returns:
@@ -314,12 +396,8 @@ class Client:
                     # In sync mode, extract outputs from the result
                     status = sync_result.get("data", {}).get("status")
                     if status != "completed":
-                        error = (
-                            sync_result.get("data", {}).get("error") or "Unknown error"
-                        )
-                        request_id = sync_result.get("data", {}).get("id", "unknown")
                         raise RuntimeError(
-                            f"Prediction failed (task_id: {request_id}): {error}"
+                            self._format_sync_mode_error(sync_result.get("data", {}))
                         )
                     data = sync_result.get("data", {})
                     return {"outputs": data.get("outputs", [])}
@@ -328,6 +406,7 @@ class Client:
 
             except Exception as e:
                 last_error = e
+
                 is_retryable = self._is_retryable_error(e)
 
                 if not is_retryable or attempt >= task_retries:

{wavespeed-1.0.8 → wavespeed-1.0.9}/src/wavespeed/config.py

@@ -84,7 +84,6 @@ def _detect_serverless_env() -> Optional[str]:
         The serverless environment type ("runpod", "waverless") or None
         if not running in a known serverless environment.
     """
-
     # Check for native Waverless environment
     if os.environ.get("WAVERLESS_ENDPOINT_ID"):
         return "waverless"

{wavespeed-1.0.8 → wavespeed-1.0.9}/src/wavespeed/serverless/modules/health.py

@@ -45,7 +45,9 @@ class HealthServer:
         """Start the health server in a background thread."""
         try:
             self._server = HTTPServer((self.host, self.port), HealthHandler)
-            self._thread = threading.Thread(target=self._server.serve_forever, daemon=True)
+            self._thread = threading.Thread(
+                target=self._server.serve_forever, daemon=True
+            )
             self._thread.start()
             log.info(f"Health server started at http://{self.host}:{self.port}/health")
         except Exception as e:

{wavespeed-1.0.8 → wavespeed-1.0.9}/src/wavespeed.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavespeed
-Version: 1.0.8
+Version: 1.0.9
 Summary: WaveSpeedAI Python Client — Official Python SDK for WaveSpeedAI inference platform
 Author-email: WaveSpeedAI <support@wavespeed.ai>
 License: MIT
@@ -93,13 +93,15 @@ output = wavespeed.run(
     {"prompt": "Cat"},
     timeout=36000.0,       # Max wait time in seconds (default: 36000.0)
     poll_interval=1.0,     # Status check interval (default: 1.0)
-    enable_sync_mode=False, # Single request mode, no polling (default: False)
+    enable_sync_mode=False, # Best-effort sync result attempt (default: False)
 )
 ```
 
 ### Sync Mode
 
-Use `enable_sync_mode=True` for a single request that waits for the result (no polling).
+Use `enable_sync_mode=True` to ask the API to wait for the result in the initial
+request. If the server-side sync wait times out, the SDK raises an error with
+the task ID/result URL; the task continues processing and can be queried later.
 
 > **Note:** Not all models support sync mode. Check the model documentation for availability.
 

{wavespeed-1.0.8 → wavespeed-1.0.9}/tests/test_api.py

@@ -171,6 +171,43 @@ class TestClient(unittest.TestCase):
             client.run("wavespeed-ai/z-image/turbo", {"prompt": "test"}, timeout=10)
         self.assertIn("timed out", str(ctx.exception))
 
+    @patch("wavespeed.api.client.requests.get")
+    @patch("wavespeed.api.client.requests.post")
+    def test_run_sync_mode_timeout_raises_without_fallback(self, mock_post, mock_get):
+        """Test sync-mode timeout keeps the task queryable without async fallback."""
+        result_url = "https://api.wavespeed.ai/api/v3/predictions/req-timeout/result"
+        mock_post_response = MagicMock()
+        mock_post_response.status_code = 200
+        mock_post_response.json.return_value = {
+            "data": {
+                "id": "req-timeout",
+                "status": "processing",
+                "code": 5004,
+                "error": (
+                    "Sync mode timed out after 90 seconds. The prediction is "
+                    "still processing asynchronously."
+                ),
+                "urls": {"get": result_url},
+            }
+        }
+        mock_post.return_value = mock_post_response
+
+        client = Client(api_key="test-key")
+        with self.assertRaises(RuntimeError) as ctx:
+            client.run(
+                "wavespeed-ai/z-image/turbo",
+                {"prompt": "test"},
+                enable_sync_mode=True,
+                max_retries=1,
+            )
+
+        error = str(ctx.exception)
+        self.assertIn("Sync mode timed out", error)
+        self.assertIn("req-timeout", error)
+        self.assertIn(result_url, error)
+        mock_post.assert_called_once()
+        mock_get.assert_not_called()
+
 
 class TestModuleLevelRun(unittest.TestCase):
     """Tests for the module-level run() function."""

{wavespeed-1.0.8 → wavespeed-1.0.9}/tests/test_config.py

@@ -43,9 +43,7 @@ class TestResolveWaverlessUrl(unittest.TestCase):
         """Test that $WAVERLESS_POD_ID is replaced with pod_id."""
         template = "https://api.wavespeed.ai/v2/test/job-take/$WAVERLESS_POD_ID"
         result = _resolve_waverless_url(template, "my-pod-123")
-        self.assertEqual(
-            result, "https://api.wavespeed.ai/v2/test/job-take/my-pod-123"
-        )
+        self.assertEqual(result, "https://api.wavespeed.ai/v2/test/job-take/my-pod-123")
 
     def test_preserves_id_placeholder(self):
         """Test that $ID is NOT replaced - it's for job/worker ID at runtime."""