fix(python): handle non-JSON error responses in HTTP decorators (#200)

The generated OpenAPI client calls response.json() for all status codes without checking Content-Type. When the server returns a plain-text error body (e.g. "Unauthorized\n" on a 401), JSONDecodeError propagates and gets wrapped as a generic RenderError with an unhelpful parse error message.

Now, we catch JSONDecodeError explicitly in handle_http_errors decorators and surface the raw response body so callers can diagnose the actual server error.

GitOrigin-RevId: e5601e666fbc56386a61cb154e7892ea262cc96d

Author: blue-keleher

python/render_sdk/client/tests/test_util.py

@@ -1,11 +1,13 @@
+import json
+
 import httpx
 import pytest
 
-from render_sdk.client.errors import ClientError, ServerError, TimeoutError
+from render_sdk.client.errors import ClientError, RenderError, ServerError, TimeoutError
 from render_sdk.client.util import (
+    _handle_wrapper_exception,
     handle_api_error,
     handle_http_error,
-    handle_http_errors,
     handle_httpx_exception,
     handle_storage_http_error,
     retry_with_backoff,
@@ -169,19 +171,39 @@ def test_handle_api_error_fallback_when_content_is_not_json():
         handle_api_error(response, "API request")
 
 
-@pytest.mark.asyncio
-async def test_decorator_handle_http_errors():
-    @handle_http_errors("test operation")
-    async def test_operation():
-        return Response(
-            status_code=400,
-            content=b"",
-            headers={},
-            parsed=Error(message="Bad request"),
-        )
+def test_handle_wrapper_exception_reraises_render_error():
+    with pytest.raises(RenderError, match="already a render error"):
+        _handle_wrapper_exception(RenderError("already a render error"), "op")
+
+
+def test_handle_wrapper_exception_httpx_request_error():
+    exc = httpx.TimeoutException("timed out")
+    with pytest.raises(TimeoutError, match="op timed out"):
+        _handle_wrapper_exception(exc, "op")
+
+
+def test_handle_wrapper_exception_json_decode_error():
+    exc = json.JSONDecodeError("Expecting value", "Unauthorized\n", 0)
+    with pytest.raises(
+        RenderError, match="server returned a non-JSON response: Unauthorized"
+    ):
+        _handle_wrapper_exception(exc, "create task")
+
+
+def test_handle_wrapper_exception_json_decode_error_empty_body():
+    exc = json.JSONDecodeError("Expecting value", "", 0)
+    with pytest.raises(
+        RenderError, match="server returned a non-JSON response: empty response"
+    ):
+        _handle_wrapper_exception(exc, "create task")
+
 
-    with pytest.raises(ClientError, match="test operation failed: Bad request"):
-        await test_operation()
+def test_handle_wrapper_exception_unexpected_error():
+    exc = ValueError("something weird")
+    with pytest.raises(
+        RenderError, match="failed with unexpected error: something weird"
+    ):
+        _handle_wrapper_exception(exc, "op")
 
 
 class TestHandleStorageHttpError:

python/render_sdk/client/tests/test_util_sync.py

@@ -3,10 +3,7 @@
 
 import pytest
 
-from render_sdk.client.errors import ClientError
-from render_sdk.client.util_sync import handle_http_errors, retry_with_backoff
-from render_sdk.public_api.models.error import Error
-from render_sdk.public_api.types import Response
+from render_sdk.client.util_sync import retry_with_backoff
 
 
 class _TestException(Exception):
@@ -74,31 +71,3 @@ def fn():
         fn, max_retries=3, poll_interval=0.001, backoff_factor=1.0
     )
     assert result is None
-
-
-def test_decorator_handle_http_errors():
-    @handle_http_errors("test operation")
-    def test_operation():
-        return Response(
-            status_code=400,
-            content=b"",
-            headers={},
-            parsed=Error(message="Bad request"),
-        )
-
-    with pytest.raises(ClientError, match="test operation failed: Bad request"):
-        test_operation()
-
-
-def test_decorator_handle_http_errors_success():
-    @handle_http_errors("test operation")
-    def test_operation():
-        return Response(
-            status_code=200,
-            content=b"",
-            headers={},
-            parsed={"data": "ok"},
-        )
-
-    result = test_operation()
-    assert result.status_code == 200

python/render_sdk/client/util.py

@@ -1,4 +1,5 @@
 import functools
+import json
 import logging
 from asyncio import sleep
 from collections.abc import Awaitable, Callable
@@ -197,8 +198,6 @@ def handle_api_error(
     elif response.parsed is None and response.content:
         # Parsed is None (e.g., 400 not handled) - try to extract from raw content
         try:
-            import json
-
             error_data = json.loads(response.content)
             if isinstance(error_data, dict):
                 message = error_data.get("message")
@@ -227,6 +226,24 @@ def handle_api_error(
         raise ClientError(full_message)
 
 
+def _handle_wrapper_exception(exc: Exception, operation: str) -> NoReturn:
+    """
+    Translate exceptions caught by handle_http_errors into custom exceptions.
+
+    Shared by both the async and sync versions of the decorator.
+    """
+    if isinstance(exc, RenderError):
+        raise exc
+    if isinstance(exc, httpx.RequestError):
+        handle_httpx_exception(exc, operation)
+    if isinstance(exc, json.JSONDecodeError):
+        body = exc.doc.strip() if exc.doc else "empty response"
+        raise RenderError(
+            f"{operation} failed: server returned a non-JSON response: {body}"
+        ) from exc
+    raise RenderError(f"{operation} failed with unexpected error: {exc}") from exc
+
+
 def handle_http_errors(operation: str):
     """
     Decorator that handles HTTPX exceptions and HTTP error responses.
@@ -250,20 +267,10 @@ def decorator(func: Callable[..., Awaitable[Response[Any | Error]]]):
         async def wrapper(*args, **kwargs):
             try:
                 result = await func(*args, **kwargs)
-
-                handle_api_error(result, operation)
-
-                return result
-
-            except httpx.RequestError as exc:
-                handle_httpx_exception(exc, operation)
-            except RenderError:
-                raise
             except Exception as exc:
-                # Unexpected exception
-                raise RenderError(
-                    f"{operation} failed with unexpected error: {exc}"
-                ) from exc
+                _handle_wrapper_exception(exc, operation)
+            handle_api_error(result, operation)
+            return result
 
         return wrapper
 

python/render_sdk/client/util_sync.py

@@ -10,10 +10,8 @@
 from time import sleep
 from typing import Any
 
-import httpx
-
-from render_sdk.client.errors import RenderError
 from render_sdk.client.util import (
+    _handle_wrapper_exception,
     handle_api_error,
     handle_http_error,
     handle_httpx_exception,
@@ -26,6 +24,7 @@
 __all__ = [
     "retry_with_backoff",
     "handle_http_errors",
+    "_handle_wrapper_exception",
     "handle_api_error",
     "handle_http_error",
     "handle_httpx_exception",
@@ -60,7 +59,8 @@ def retry_with_backoff(
 
 
 def handle_http_errors(operation: str):
-    """Decorator that handles HTTPX exceptions and HTTP error responses.
+    """
+    Decorator that handles HTTPX exceptions and HTTP error responses.
 
     Sync version of the decorator in util.py.
 
@@ -73,20 +73,10 @@ def decorator(func: Callable[..., Response[Any | Error]]):
         def wrapper(*args, **kwargs):
             try:
                 result = func(*args, **kwargs)
-
-                handle_api_error(result, operation)
-
-                return result
-
-            except httpx.RequestError as exc:
-                handle_httpx_exception(exc, operation)
-            except RenderError:
-                raise
             except Exception as exc:
-                # Unexpected exception
-                raise RenderError(
-                    f"{operation} failed with unexpected error: {exc}"
-                ) from exc
+                _handle_wrapper_exception(exc, operation)
+            handle_api_error(result, operation)
+            return result
 
         return wrapper