108 lines
2.9 KiB
Python
108 lines
2.9 KiB
Python
from typing import TYPE_CHECKING, Optional
|
|
|
|
import httpx
|
|
|
|
if TYPE_CHECKING:
|
|
from replicate.prediction import Prediction
|
|
|
|
|
|
class ReplicateException(Exception):
|
|
"""A base class for all Replicate exceptions."""
|
|
|
|
|
|
class ModelError(ReplicateException):
|
|
"""An error from user's code in a model."""
|
|
|
|
prediction: "Prediction"
|
|
|
|
def __init__(self, prediction: "Prediction") -> None:
|
|
self.prediction = prediction
|
|
super().__init__(prediction.error)
|
|
|
|
|
|
class ReplicateError(ReplicateException):
|
|
"""
|
|
An error from Replicate's API.
|
|
|
|
This class represents a problem details response as defined in RFC 7807.
|
|
"""
|
|
|
|
type: Optional[str]
|
|
"""A URI that identifies the error type."""
|
|
|
|
title: Optional[str]
|
|
"""A short, human-readable summary of the error."""
|
|
|
|
status: Optional[int]
|
|
"""The HTTP status code."""
|
|
|
|
detail: Optional[str]
|
|
"""A human-readable explanation specific to this occurrence of the error."""
|
|
|
|
instance: Optional[str]
|
|
"""A URI that identifies the specific occurrence of the error."""
|
|
|
|
def __init__( # pylint: disable=too-many-arguments
|
|
self,
|
|
type: Optional[str] = None,
|
|
title: Optional[str] = None,
|
|
status: Optional[int] = None,
|
|
detail: Optional[str] = None,
|
|
instance: Optional[str] = None,
|
|
) -> None:
|
|
self.type = type
|
|
self.title = title
|
|
self.status = status
|
|
self.detail = detail
|
|
self.instance = instance
|
|
|
|
@classmethod
|
|
def from_response(cls, response: httpx.Response) -> "ReplicateError":
|
|
"""Create a ReplicateError from an HTTP response."""
|
|
|
|
try:
|
|
data = response.json()
|
|
except ValueError:
|
|
data = {}
|
|
|
|
return cls(
|
|
type=data.get("type"),
|
|
title=data.get("title"),
|
|
detail=data.get("detail"),
|
|
status=response.status_code,
|
|
instance=data.get("instance"),
|
|
)
|
|
|
|
def to_dict(self) -> dict:
|
|
"""Get a dictionary representation of the error."""
|
|
|
|
return {
|
|
key: value
|
|
for key, value in {
|
|
"type": self.type,
|
|
"title": self.title,
|
|
"status": self.status,
|
|
"detail": self.detail,
|
|
"instance": self.instance,
|
|
}.items()
|
|
if value is not None
|
|
}
|
|
|
|
def __str__(self) -> str:
|
|
return "ReplicateError Details:\n" + "\n".join(
|
|
[f"{key}: {value}" for key, value in self.to_dict().items()]
|
|
)
|
|
|
|
def __repr__(self) -> str:
|
|
class_name = self.__class__.__name__
|
|
params = ", ".join(
|
|
[
|
|
f"type={repr(self.type)}",
|
|
f"title={repr(self.title)}",
|
|
f"status={repr(self.status)}",
|
|
f"detail={repr(self.detail)}",
|
|
f"instance={repr(self.instance)}",
|
|
]
|
|
)
|
|
return f"{class_name}({params})"
|