bytekit-sdk 0.3.0__py3-none-any.whl

bytekit/models/create_search_response_200_results_item_image.py

@@ -0,0 +1,113 @@
+from collections.abc import Mapping
+from typing import (
+    Any,
+    TypeVar,
+    Union,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CreateSearchResponse200ResultsItemImage")
+
+
+@_attrs_define
+class CreateSearchResponse200ResultsItemImage:
+    """Image attached to the result. For `news` results this is the thumbnail (only `url`). For `images` results it is the
+    full image, additionally carrying its dimensions and a thumbnail URL + dimensions. Each field past `url` is present
+    only when the provider reports it.
+
+        Attributes:
+            url (str): URL of the image (thumbnail for `news`, full image for `images`).
+            width (Union[Unset, int]): Source image width in pixels (`images` only).
+            height (Union[Unset, int]): Source image height in pixels (`images` only).
+            thumbnail_url (Union[Unset, str]): URL of the thumbnail image (`images` only).
+            thumbnail_width (Union[Unset, int]): Thumbnail width in pixels (`images` only).
+            thumbnail_height (Union[Unset, int]): Thumbnail height in pixels (`images` only).
+    """
+
+    url: str
+    width: Union[Unset, int] = UNSET
+    height: Union[Unset, int] = UNSET
+    thumbnail_url: Union[Unset, str] = UNSET
+    thumbnail_width: Union[Unset, int] = UNSET
+    thumbnail_height: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        url = self.url
+
+        width = self.width
+
+        height = self.height
+
+        thumbnail_url = self.thumbnail_url
+
+        thumbnail_width = self.thumbnail_width
+
+        thumbnail_height = self.thumbnail_height
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "url": url,
+            }
+        )
+        if width is not UNSET:
+            field_dict["width"] = width
+        if height is not UNSET:
+            field_dict["height"] = height
+        if thumbnail_url is not UNSET:
+            field_dict["thumbnail_url"] = thumbnail_url
+        if thumbnail_width is not UNSET:
+            field_dict["thumbnail_width"] = thumbnail_width
+        if thumbnail_height is not UNSET:
+            field_dict["thumbnail_height"] = thumbnail_height
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        url = d.pop("url")
+
+        width = d.pop("width", UNSET)
+
+        height = d.pop("height", UNSET)
+
+        thumbnail_url = d.pop("thumbnail_url", UNSET)
+
+        thumbnail_width = d.pop("thumbnail_width", UNSET)
+
+        thumbnail_height = d.pop("thumbnail_height", UNSET)
+
+        create_search_response_200_results_item_image = cls(
+            url=url,
+            width=width,
+            height=height,
+            thumbnail_url=thumbnail_url,
+            thumbnail_width=thumbnail_width,
+            thumbnail_height=thumbnail_height,
+        )
+
+        create_search_response_200_results_item_image.additional_properties = d
+        return create_search_response_200_results_item_image
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

bytekit/models/create_search_response_502.py

@@ -0,0 +1,46 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+
+from ..models.create_search_response_502_error import CreateSearchResponse502Error
+
+T = TypeVar("T", bound="CreateSearchResponse502")
+
+
+@_attrs_define
+class CreateSearchResponse502:
+    """
+    Example:
+        {'error': 'search_provider_error'}
+
+    Attributes:
+        error (CreateSearchResponse502Error): Fixed vendor-masked error code. Always `search_provider_error`; the
+            upstream provider's identity and failure detail are withheld by design.
+    """
+
+    error: CreateSearchResponse502Error
+
+    def to_dict(self) -> dict[str, Any]:
+        error = self.error.value
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "error": error,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        error = CreateSearchResponse502Error(d.pop("error"))
+
+        create_search_response_502 = cls(
+            error=error,
+        )
+
+        return create_search_response_502

bytekit/models/create_search_response_502_error.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class CreateSearchResponse502Error(str, Enum):
+    SEARCH_PROVIDER_ERROR = "search_provider_error"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/credit_balance.py

@@ -0,0 +1,91 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="CreditBalance")
+
+
+@_attrs_define
+class CreditBalance:
+    """
+    Attributes:
+        used (int):
+        limit (int):
+        remaining (int):
+        topup_credits (int):
+        rollover_credits (int):
+    """
+
+    used: int
+    limit: int
+    remaining: int
+    topup_credits: int
+    rollover_credits: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        used = self.used
+
+        limit = self.limit
+
+        remaining = self.remaining
+
+        topup_credits = self.topup_credits
+
+        rollover_credits = self.rollover_credits
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "used": used,
+                "limit": limit,
+                "remaining": remaining,
+                "topup_credits": topup_credits,
+                "rollover_credits": rollover_credits,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        used = d.pop("used")
+
+        limit = d.pop("limit")
+
+        remaining = d.pop("remaining")
+
+        topup_credits = d.pop("topup_credits")
+
+        rollover_credits = d.pop("rollover_credits")
+
+        credit_balance = cls(
+            used=used,
+            limit=limit,
+            remaining=remaining,
+            topup_credits=topup_credits,
+            rollover_credits=rollover_credits,
+        )
+
+        credit_balance.additional_properties = d
+        return credit_balance
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

bytekit/models/delete_bulk_response_200.py

@@ -0,0 +1,164 @@
+import datetime
+from collections.abc import Mapping
+from typing import (
+    Any,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..models.delete_bulk_response_200_status import DeleteBulkResponse200Status
+
+T = TypeVar("T", bound="DeleteBulkResponse200")
+
+
+@_attrs_define
+class DeleteBulkResponse200:
+    """
+    Attributes:
+        id (str):  Example: bulk_01j9abc123.
+        status (DeleteBulkResponse200Status):
+        total (int):
+        completed (int):
+        failed (int):
+        created_at (datetime.datetime):
+        completed_at (Union[None, datetime.datetime]):
+        total_credits_charged (int):
+        estimated_credits (Union[None, int]): Null in cancel responses (computed at submission time only).
+        webhook_url (str): Webhook endpoint URL (HTTPS only; http:// rejected with 400 invalid_url, reason
+            scheme_unsupported)
+    """
+
+    id: str
+    status: DeleteBulkResponse200Status
+    total: int
+    completed: int
+    failed: int
+    created_at: datetime.datetime
+    completed_at: Union[None, datetime.datetime]
+    total_credits_charged: int
+    estimated_credits: Union[None, int]
+    webhook_url: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        status = self.status.value
+
+        total = self.total
+
+        completed = self.completed
+
+        failed = self.failed
+
+        created_at = self.created_at.isoformat()
+
+        completed_at: Union[None, str]
+        if isinstance(self.completed_at, datetime.datetime):
+            completed_at = self.completed_at.isoformat()
+        else:
+            completed_at = self.completed_at
+
+        total_credits_charged = self.total_credits_charged
+
+        estimated_credits: Union[None, int]
+        estimated_credits = self.estimated_credits
+
+        webhook_url = self.webhook_url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "status": status,
+                "total": total,
+                "completed": completed,
+                "failed": failed,
+                "created_at": created_at,
+                "completed_at": completed_at,
+                "total_credits_charged": total_credits_charged,
+                "estimated_credits": estimated_credits,
+                "webhook_url": webhook_url,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        status = DeleteBulkResponse200Status(d.pop("status"))
+
+        total = d.pop("total")
+
+        completed = d.pop("completed")
+
+        failed = d.pop("failed")
+
+        created_at = isoparse(d.pop("created_at"))
+
+        def _parse_completed_at(data: object) -> Union[None, datetime.datetime]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                completed_at_type_0 = isoparse(data)
+
+                return completed_at_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, datetime.datetime], data)
+
+        completed_at = _parse_completed_at(d.pop("completed_at"))
+
+        total_credits_charged = d.pop("total_credits_charged")
+
+        def _parse_estimated_credits(data: object) -> Union[None, int]:
+            if data is None:
+                return data
+            return cast(Union[None, int], data)
+
+        estimated_credits = _parse_estimated_credits(d.pop("estimated_credits"))
+
+        webhook_url = d.pop("webhook_url")
+
+        delete_bulk_response_200 = cls(
+            id=id,
+            status=status,
+            total=total,
+            completed=completed,
+            failed=failed,
+            created_at=created_at,
+            completed_at=completed_at,
+            total_credits_charged=total_credits_charged,
+            estimated_credits=estimated_credits,
+            webhook_url=webhook_url,
+        )
+
+        delete_bulk_response_200.additional_properties = d
+        return delete_bulk_response_200
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

bytekit/models/delete_bulk_response_200_status.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class DeleteBulkResponse200Status(str, Enum):
+    CANCELLED = "cancelled"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    PROCESSING = "processing"
+
+    def __str__(self) -> str:
+        return str(self.value)

bytekit/models/error.py

@@ -0,0 +1,83 @@
+from collections.abc import Mapping
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeVar,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.error_status import ErrorStatus
+
+if TYPE_CHECKING:
+    from ..models.error_error import ErrorError
+
+
+T = TypeVar("T", bound="Error")
+
+
+@_attrs_define
+class Error:
+    """Canonical 4xx/5xx error envelope used by every public-API route
+    (issue #699). `status` is the top-level discriminator so clients can
+    match on the body alone, without re-checking HTTP status. `http_status`
+    mirrors the HTTP response status for replayed or logged bodies.
+
+        Attributes:
+            status (ErrorStatus): Top-level discriminator. Always `failed` for error responses.
+            error (ErrorError):
+    """
+
+    status: ErrorStatus
+    error: "ErrorError"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        status = self.status.value
+
+        error = self.error.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status": status,
+                "error": error,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.error_error import ErrorError
+
+        d = dict(src_dict)
+        status = ErrorStatus(d.pop("status"))
+
+        error = ErrorError.from_dict(d.pop("error"))
+
+        error = cls(
+            status=status,
+            error=error,
+        )
+
+        error.additional_properties = d
+        return error
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

bytekit/models/error_error.py

@@ -0,0 +1,100 @@
+import datetime
+from collections.abc import Mapping
+from typing import (
+    Any,
+    TypeVar,
+    Union,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ErrorError")
+
+
+@_attrs_define
+class ErrorError:
+    """
+    Attributes:
+        code (str): Machine-readable error code.
+        message (str): Human-readable error message.
+        http_status (int): HTTP status code (mirrors the response status for replayed bodies).
+        failed_at (datetime.datetime): ISO-8601 UTC timestamp when the error was emitted.
+        details (Union[Unset, Any]): Optional structured details (e.g. which fields failed validation).
+    """
+
+    code: str
+    message: str
+    http_status: int
+    failed_at: datetime.datetime
+    details: Union[Unset, Any] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        code = self.code
+
+        message = self.message
+
+        http_status = self.http_status
+
+        failed_at = self.failed_at.isoformat()
+
+        details = self.details
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "code": code,
+                "message": message,
+                "http_status": http_status,
+                "failed_at": failed_at,
+            }
+        )
+        if details is not UNSET:
+            field_dict["details"] = details
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        code = d.pop("code")
+
+        message = d.pop("message")
+
+        http_status = d.pop("http_status")
+
+        failed_at = isoparse(d.pop("failed_at"))
+
+        details = d.pop("details", UNSET)
+
+        error_error = cls(
+            code=code,
+            message=message,
+            http_status=http_status,
+            failed_at=failed_at,
+            details=details,
+        )
+
+        error_error.additional_properties = d
+        return error_error
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

bytekit/models/error_status.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class ErrorStatus(str, Enum):
+    FAILED = "failed"
+
+    def __str__(self) -> str:
+        return str(self.value)