unique-sdk 2026.44.0.dev14__tar.gz → 2026.44.0.dev15__tar.gz

{unique_sdk-2026.44.0.dev14 → unique_sdk-2026.44.0.dev15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-sdk
-Version: 2026.44.0.dev14
+Version: 2026.44.0.dev15
 Summary: 
 Author: Martin Fadler, Konstantin Krauss, Andreas Hauri
 Author-email: Martin Fadler <martin.fadler@unique.ch>, Konstantin Krauss <konstantin@unique.ch>, Andreas Hauri <andreas@unique.ch>

{unique_sdk-2026.44.0.dev14 → unique_sdk-2026.44.0.dev15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_sdk"
-version = "2026.44.0.dev14"
+version = "2026.44.0.dev15"
 description = ""
 readme = "README.md"
 license = { text = "MIT" }

{unique_sdk-2026.44.0.dev14 → unique_sdk-2026.44.0.dev15}/unique_sdk/__init__.py

@@ -34,6 +34,7 @@ from unique_sdk._error import APIConnectionError as APIConnectionError
 from unique_sdk._error import APIError as APIError
 from unique_sdk._error import AuthenticationError as AuthenticationError
 from unique_sdk._error import InvalidRequestError as InvalidRequestError
+from unique_sdk._error import RateLimitError as RateLimitError
 from unique_sdk._error import (
     SignatureVerificationError as SignatureVerificationError,
 )

{unique_sdk-2026.44.0.dev14 → unique_sdk-2026.44.0.dev15}/unique_sdk/_api_requestor.py

@@ -392,7 +392,15 @@ class APIRequestor(object):
         cause = error_data.get("cause", {})
         if isinstance(cause, str):
             cause = {"error": {"message": cause}, "status": rcode}
-        status = cause.get("status", rcode)
+
+        cause_error = cause.get("error") or {}
+        cause_code = cause_error.get("code")
+        cause_message = cause_error.get("message")
+
+        message = error_data.get("message") or cause_message
+        code = error_data.get("code") or cause_code
+        params = error_data.get("params") or cause_error.get("params")
+        status = rcode if error_data.get("code") else cause.get("status", rcode)
 
         _util.log_info(
             "Unique error received",
@@ -402,46 +410,63 @@ class APIRequestor(object):
             error_params=_util.redacted_error_params(error_data.get("params")),
         )
 
-        error = cause.get("error", {}) if cause else {}
-        error_code = error.get("code", "<Unknown code>")
-        error_message = error.get("message", "<No message>")
-        original_error = f"{error_code}: {error_message}"
+        original_error = None
+        if cause_code or cause_message:
+            original_error = (
+                f"{cause_code or '<Unknown code>'}: {cause_message or '<No message>'}"
+            )
 
-        if status in [400, 404]:
-            return _error.InvalidRequestError(
-                message=error_data.get("message"),
-                params=error_data.get("params"),
-                code=error_data.get("code"),
+        if status == 429:
+            return _error.RateLimitError(
+                message=message,
+                params=params,
+                code=code,
                 http_body=rbody,
                 http_status=rcode,
                 json_body=resp,
                 headers=rheaders,
                 original_error=original_error,
             )
-        elif status == 401:
-            return _error.AuthenticationError(
-                message=error_data.get("message"),
+        if status in [400, 404]:
+            return _error.InvalidRequestError(
+                message=message,
+                params=params,
+                code=code,
                 http_body=rbody,
-                http_status=status,
+                http_status=rcode,
                 json_body=resp,
                 headers=rheaders,
                 original_error=original_error,
             )
-        elif status == 403:
-            return _error.PermissionError(
-                message=error_data.get("message"),
+        if status == 401:
+            return _error.AuthenticationError(
+                message=message,
                 http_body=rbody,
                 http_status=status,
                 json_body=resp,
                 headers=rheaders,
+                code=code,
                 original_error=original_error,
+                params=params,
             )
-        else:
-            return _error.APIError(
-                message=error_data.get("message"),
+        if status == 403:
+            return _error.PermissionError(
+                message=message,
                 http_body=rbody,
                 http_status=status,
                 json_body=resp,
                 headers=rheaders,
+                code=code,
                 original_error=original_error,
+                params=params,
             )
+        return _error.APIError(
+            message=message,
+            http_body=rbody,
+            http_status=status,
+            json_body=resp,
+            headers=rheaders,
+            code=code,
+            original_error=original_error,
+            params=params,
+        )

{unique_sdk-2026.44.0.dev14 → unique_sdk-2026.44.0.dev15}/unique_sdk/_error.py

@@ -1,4 +1,4 @@
-from typing import cast
+from typing import Any, cast
 
 
 class UniqueError(Exception):
@@ -10,6 +10,7 @@ class UniqueError(Exception):
     code: str | None
     request_id: str | None
     original_error: Exception | str | None
+    params: dict[str, Any] | str | None
 
     def __init__(
         self,
@@ -20,6 +21,7 @@ class UniqueError(Exception):
         headers: dict[str, str] | None = None,
         code: str | None = None,
         original_error: Exception | str | None = None,
+        params: dict[str, Any] | str | None = None,
     ):
         super(UniqueError, self).__init__(message)
 
@@ -41,6 +43,7 @@ class UniqueError(Exception):
         self.code = code
         self.request_id = self.headers.get("request-id", None)
         self.original_error = original_error
+        self.params = params
 
     def __str__(self):
         msg = self._message or "<empty message>"
@@ -51,7 +54,7 @@ class UniqueError(Exception):
 
 class UniqueErrorWithParamsCode(UniqueError):
     # str included: InvalidRequestError callers pass plain strings (e.g. "id")
-    params: dict[str, str] | str | None
+    params: dict[str, Any] | str | None
 
     def __init__(
         self,
@@ -62,12 +65,18 @@ class UniqueErrorWithParamsCode(UniqueError):
         headers: dict[str, str] | None = None,
         code: str | None = None,
         original_error: Exception | str | None = None,
-        params: dict[str, str] | str | None = None,
+        params: dict[str, Any] | str | None = None,
     ):
         super().__init__(
-            message, http_body, http_status, json_body, headers, code, original_error
+            message,
+            http_body,
+            http_status,
+            json_body,
+            headers,
+            code,
+            original_error,
+            params,
         )
-        self.params = params
 
     def __repr__(self):
         return "%s(message=%r, params=%r, code=%r, http_status=%r, request_id=%r)" % (
@@ -112,6 +121,10 @@ class PermissionError(UniqueError):
     pass
 
 
+class RateLimitError(APIError):
+    pass
+
+
 class InvalidRequestError(UniqueErrorWithParamsCode):
     def __init__(
         self,

{unique_sdk-2026.44.0.dev14 → unique_sdk-2026.44.0.dev15}/unique_sdk/_util.py

@@ -333,6 +333,35 @@ class class_method_variant(object):
         return _wrapper
 
 
+def _should_retry_error(
+    error: UniqueError,
+    error_messages: list[str],
+    should_retry_5xx: bool,
+) -> bool:
+    status = error.http_status
+    if status is not None and 400 <= status < 500:
+        return False
+    if isinstance(error.params, Mapping) and error.params.get("retryable") is False:
+        return False
+    if should_retry_5xx and status is not None and 500 <= status < 600:
+        return True
+    return any(err_msg.lower() in str(error).lower() for err_msg in error_messages)
+
+
+def _log_retry(error: UniqueError, attempt: int, max_retries: int) -> None:
+    # str(error) can carry upstream provider text via original_error.
+    params = error.params if isinstance(error.params, Mapping) else {}
+    logger.warning(
+        "Retrying Unique API call, attempt %d of %d: "
+        "code=%s http_status=%s correlation_id=%s",
+        attempt + 1,
+        max_retries,
+        error.code,
+        error.http_status,
+        params.get("correlationId"),
+    )
+
+
 def retry_on_error(
     error_messages: list[str],
     max_retries: int = 3,
@@ -341,6 +370,13 @@ def retry_on_error(
     error_class=APIError,
     should_retry_5xx=False,
 ):
+    """Retry ``APIError`` and ``APIConnectionError``.
+
+    4xx responses and errors with ``params.retryable`` false are not retried.
+    After the last attempt ``error_class`` is raised with the last error as
+    its ``__cause__``.
+    """
+
     def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
         @wraps(func)
         async def async_wrapper(*args, **kwargs) -> Any:
@@ -350,25 +386,16 @@ def retry_on_error(
                     return await func(*args, **kwargs)
                 except (APIError, APIConnectionError) as e:
                     e = cast(UniqueError, e)
-                    logger.error(f"Retrying because of {e}")
-                    should_retry = any(
-                        err_msg.lower() in str(e).lower() for err_msg in error_messages
-                    )
-                    # Add 5xx check if `should_retry_5xx` is True
-                    has_valid_status = (
-                        hasattr(e, "http_status") and e.http_status is not None
-                    )
-                    if should_retry_5xx and has_valid_status:
-                        should_retry = should_retry or (
-                            500 <= int(cast(int, e.http_status)) < 600
-                        )
-
-                    if not should_retry:
-                        raise e  # Raise the error if no retry condition is met
+                    if not _should_retry_error(e, error_messages, should_retry_5xx):
+                        raise
 
                     attempts += 1
                     if attempts >= max_retries:
-                        raise error_class(f"Failed after {max_retries} attempts: {e}")
+                        raise error_class(
+                            f"Failed after {max_retries} attempts: {e}"
+                        ) from e
+
+                    _log_retry(e, attempts, max_retries)
 
                     # Calculate exponential backoff with some randomness (jitter)
                     delay = initial_delay * (backoff_factor ** (attempts - 1))
@@ -382,25 +409,16 @@ def retry_on_error(
                     return func(*args, **kwargs)
                 except (APIError, APIConnectionError) as e:
                     e = cast(UniqueError, e)
-                    logger.error(f"Retrying because of {e}")
-                    should_retry = any(
-                        err_msg.lower() in str(e).lower() for err_msg in error_messages
-                    )
-                    # Add 5xx check if `should_retry_5xx` is True
-                    has_valid_status = (
-                        hasattr(e, "http_status") and e.http_status is not None
-                    )
-                    if should_retry_5xx and has_valid_status:
-                        should_retry = should_retry or (
-                            500 <= int(cast(int, e.http_status)) < 600
-                        )
-
-                    if not should_retry:
-                        raise e  # Raise the error if no retry condition is met
+                    if not _should_retry_error(e, error_messages, should_retry_5xx):
+                        raise
 
                     attempts += 1
                     if attempts >= max_retries:
-                        raise error_class(f"Failed after {max_retries} attempts: {e}")
+                        raise error_class(
+                            f"Failed after {max_retries} attempts: {e}"
+                        ) from e
+
+                    _log_retry(e, attempts, max_retries)
 
                     # Calculate exponential backoff with some randomness (jitter)
                     delay = initial_delay * (backoff_factor ** (attempts - 1))