compass_api_sdk 0.9.35__py3-none-any.whl → 2.0.21rc1__py3-none-any.whl

compass_api_sdk/errors/__init__.py

@@ -1,21 +1,55 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
+from .compassapierror import CompassAPIError
 from typing import TYPE_CHECKING
 from importlib import import_module
+import builtins
+import sys
 
 if TYPE_CHECKING:
     from .apierror import APIError
     from .httpvalidationerror import HTTPValidationError, HTTPValidationErrorData
+    from .mintpreparenotfoundresponse_error import (
+        MintPrepareNotFoundResponseError,
+        MintPrepareNotFoundResponseErrorData,
+    )
+    from .no_response_error import NoResponseError
+    from .responsevalidationerror import ResponseValidationError
 
-__all__ = ["APIError", "HTTPValidationError", "HTTPValidationErrorData"]
+__all__ = [
+    "APIError",
+    "CompassAPIError",
+    "HTTPValidationError",
+    "HTTPValidationErrorData",
+    "MintPrepareNotFoundResponseError",
+    "MintPrepareNotFoundResponseErrorData",
+    "NoResponseError",
+    "ResponseValidationError",
+]
 
 _dynamic_imports: dict[str, str] = {
     "APIError": ".apierror",
     "HTTPValidationError": ".httpvalidationerror",
     "HTTPValidationErrorData": ".httpvalidationerror",
+    "MintPrepareNotFoundResponseError": ".mintpreparenotfoundresponse_error",
+    "MintPrepareNotFoundResponseErrorData": ".mintpreparenotfoundresponse_error",
+    "NoResponseError": ".no_response_error",
+    "ResponseValidationError": ".responsevalidationerror",
 }
 
 
+def dynamic_import(modname, retries=3):
+    for attempt in range(retries):
+        try:
+            return import_module(modname, __package__)
+        except KeyError:
+            # Clear any half-initialized module and retry
+            sys.modules.pop(modname, None)
+            if attempt == retries - 1:
+                break
+    raise KeyError(f"Failed to import module '{modname}' after {retries} attempts")
+
+
 def __getattr__(attr_name: str) -> object:
     module_name = _dynamic_imports.get(attr_name)
     if module_name is None:
@@ -24,7 +58,7 @@ def __getattr__(attr_name: str) -> object:
         )
 
     try:
-        module = import_module(module_name, __package__)
+        module = dynamic_import(module_name)
         result = getattr(module, attr_name)
         return result
     except ImportError as e:
@@ -38,5 +72,5 @@ def __getattr__(attr_name: str) -> object:
 
 
 def __dir__():
-    lazy_attrs = list(_dynamic_imports.keys())
-    return sorted(lazy_attrs)
+    lazy_attrs = builtins.list(_dynamic_imports.keys())
+    return builtins.sorted(lazy_attrs)

compass_api_sdk/errors/apierror.py

@@ -1,22 +1,40 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
-from dataclasses import dataclass
-from typing import Optional
 import httpx
+from typing import Optional
+from dataclasses import dataclass
+
+from compass_api_sdk.errors import CompassAPIError
+
+MAX_MESSAGE_LEN = 10_000
+
+
+@dataclass(unsafe_hash=True)
+class APIError(CompassAPIError):
+    """The fallback error class if no more specific error class is matched."""
+
+    def __init__(
+        self, message: str, raw_response: httpx.Response, body: Optional[str] = None
+    ):
+        body_display = body or raw_response.text or '""'
 
+        if message:
+            message += ": "
+        message += f"Status {raw_response.status_code}"
 
-@dataclass
-class APIError(Exception):
-    """Represents an error returned by the API."""
+        headers = raw_response.headers
+        content_type = headers.get("content-type", '""')
+        if content_type != "application/json":
+            if " " in content_type:
+                content_type = f'"{content_type}"'
+            message += f" Content-Type {content_type}"
 
-    message: str
-    status_code: int = -1
-    body: str = ""
-    raw_response: Optional[httpx.Response] = None
+        if len(body_display) > MAX_MESSAGE_LEN:
+            truncated = body_display[:MAX_MESSAGE_LEN]
+            remaining = len(body_display) - MAX_MESSAGE_LEN
+            body_display = f"{truncated}...and {remaining} more chars"
 
-    def __str__(self):
-        body = ""
-        if len(self.body) > 0:
-            body = f"\n{self.body}"
+        message += f". Body: {body_display}"
+        message = message.strip()
 
-        return f"{self.message}: Status {self.status_code}{body}"
+        super().__init__(message, raw_response, body)

compass_api_sdk/errors/compassapierror.py

@@ -0,0 +1,30 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import httpx
+from typing import Optional
+from dataclasses import dataclass, field
+
+
+@dataclass(unsafe_hash=True)
+class CompassAPIError(Exception):
+    """The base class for all HTTP error responses."""
+
+    message: str
+    status_code: int
+    body: str
+    headers: httpx.Headers = field(hash=False)
+    raw_response: httpx.Response = field(hash=False)
+
+    def __init__(
+        self, message: str, raw_response: httpx.Response, body: Optional[str] = None
+    ):
+        object.__setattr__(self, "message", message)
+        object.__setattr__(self, "status_code", raw_response.status_code)
+        object.__setattr__(
+            self, "body", body if body is not None else raw_response.text
+        )
+        object.__setattr__(self, "headers", raw_response.headers)
+        object.__setattr__(self, "raw_response", raw_response)
+
+    def __str__(self):
+        return self.message

compass_api_sdk/errors/httpvalidationerror.py

@@ -1,9 +1,11 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from compass_api_sdk import utils
+from compass_api_sdk.errors import CompassAPIError
 from compass_api_sdk.models import validationerror as models_validationerror
 from compass_api_sdk.types import BaseModel
+from dataclasses import dataclass, field
+import httpx
 from typing import List, Optional
 
 
@@ -11,11 +13,16 @@ class HTTPValidationErrorData(BaseModel):
     detail: Optional[List[models_validationerror.ValidationError]] = None
 
 
-class HTTPValidationError(Exception):
-    data: HTTPValidationErrorData
+@dataclass(unsafe_hash=True)
+class HTTPValidationError(CompassAPIError):
+    data: HTTPValidationErrorData = field(hash=False)
 
-    def __init__(self, data: HTTPValidationErrorData):
-        self.data = data
-
-    def __str__(self) -> str:
-        return utils.marshal_json(self.data, HTTPValidationErrorData)
+    def __init__(
+        self,
+        data: HTTPValidationErrorData,
+        raw_response: httpx.Response,
+        body: Optional[str] = None,
+    ):
+        message = body or raw_response.text
+        super().__init__(message, raw_response, body)
+        object.__setattr__(self, "data", data)

compass_api_sdk/errors/mintpreparenotfoundresponse_error.py

@@ -0,0 +1,49 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from compass_api_sdk.errors import CompassAPIError
+from compass_api_sdk.types import BaseModel
+from compass_api_sdk.utils import validate_const
+from dataclasses import dataclass, field
+import httpx
+import pydantic
+from pydantic.functional_validators import AfterValidator
+from typing import Literal, Optional
+from typing_extensions import Annotated
+
+
+class MintPrepareNotFoundResponseErrorData(BaseModel):
+    bridge_id: str
+    r"""The bridge identifier."""
+    message: str
+    r"""Human-readable message explaining the status."""
+    STATUS: Annotated[
+        Annotated[
+            Optional[Literal["burn_not_found"]],
+            AfterValidator(validate_const("burn_not_found")),
+        ],
+        pydantic.Field(alias="status"),
+    ] = "burn_not_found"
+    r"""Indicates the burn event was not found on the source chain."""
+
+
+@dataclass(unsafe_hash=True)
+class MintPrepareNotFoundResponseError(CompassAPIError):
+    r"""Response when the burn event has not been found yet.
+
+    This means the burn transaction hasn't been confirmed on-chain yet, or the user
+    hasn't broadcast the burn transaction.
+    """
+
+    data: MintPrepareNotFoundResponseErrorData = field(hash=False)
+
+    def __init__(
+        self,
+        data: MintPrepareNotFoundResponseErrorData,
+        raw_response: httpx.Response,
+        body: Optional[str] = None,
+    ):
+        fallback = body or raw_response.text
+        message = str(data.message) or fallback
+        super().__init__(message, raw_response, body)
+        object.__setattr__(self, "data", data)

compass_api_sdk/errors/no_response_error.py

@@ -0,0 +1,17 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from dataclasses import dataclass
+
+
+@dataclass(unsafe_hash=True)
+class NoResponseError(Exception):
+    """Error raised when no HTTP response is received from the server."""
+
+    message: str
+
+    def __init__(self, message: str = "No response received"):
+        object.__setattr__(self, "message", message)
+        super().__init__(message)
+
+    def __str__(self):
+        return self.message

compass_api_sdk/errors/responsevalidationerror.py

@@ -0,0 +1,27 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import httpx
+from typing import Optional
+from dataclasses import dataclass
+
+from compass_api_sdk.errors import CompassAPIError
+
+
+@dataclass(unsafe_hash=True)
+class ResponseValidationError(CompassAPIError):
+    """Error raised when there is a type mismatch between the response data and the expected Pydantic model."""
+
+    def __init__(
+        self,
+        message: str,
+        raw_response: httpx.Response,
+        cause: Exception,
+        body: Optional[str] = None,
+    ):
+        message = f"{message}: {cause}"
+        super().__init__(message, raw_response, body)
+
+    @property
+    def cause(self):
+        """Normally the Pydantic ValidationError"""
+        return self.__cause__