hushscript 1.0.0__py3-none-any.whl

hushscript/generated/models/error.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.error_details import ErrorDetails
+    from ..models.upload_limits import UploadLimits
+
+
+T = TypeVar("T", bound="Error")
+
+
+@_attrs_define
+class Error:
+    """The frozen /v1 error body. error and code are always present together; the remaining keys are optional detail this
+    API includes only when the specific error carries them, and they are omitted rather than emitted as null when
+    absent.
+
+        Attributes:
+            error (str): The error's slug. See x-error-catalog for the full list.
+            code (int): The error's stable numeric code. See x-error-catalog. Never reused or renumbered.
+            needed_seconds (int | Unset): Seconds the failed action needed. Present on a balance-shortfall error.
+            balance_seconds (int | Unset): The account's personal balance in seconds. Present on a personal balance-
+                shortfall error.
+            held_seconds (int | Unset): Seconds already committed to other in-flight jobs. Present alongside
+                balance_seconds.
+            org_balance_seconds (int | Unset): The organization's shared pool balance in seconds. Present on an org-funded
+                balance-shortfall error instead of balance_seconds.
+            limits (UploadLimits | Unset): The caller's current upload admission limits, shared by every response that
+                carries them.
+            details (ErrorDetails | Unset): Structured recovery detail for an error that is not a plain balance shortfall.
+                Present on agent_pack_locked and agent_purchase_capped.
+    """
+
+    error: str
+    code: int
+    needed_seconds: int | Unset = UNSET
+    balance_seconds: int | Unset = UNSET
+    held_seconds: int | Unset = UNSET
+    org_balance_seconds: int | Unset = UNSET
+    limits: UploadLimits | Unset = UNSET
+    details: ErrorDetails | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        error = self.error
+
+        code = self.code
+
+        needed_seconds = self.needed_seconds
+
+        balance_seconds = self.balance_seconds
+
+        held_seconds = self.held_seconds
+
+        org_balance_seconds = self.org_balance_seconds
+
+        limits: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.limits, Unset):
+            limits = self.limits.to_dict()
+
+        details: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.details, Unset):
+            details = self.details.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "error": error,
+                "code": code,
+            }
+        )
+        if needed_seconds is not UNSET:
+            field_dict["needed_seconds"] = needed_seconds
+        if balance_seconds is not UNSET:
+            field_dict["balance_seconds"] = balance_seconds
+        if held_seconds is not UNSET:
+            field_dict["held_seconds"] = held_seconds
+        if org_balance_seconds is not UNSET:
+            field_dict["org_balance_seconds"] = org_balance_seconds
+        if limits is not UNSET:
+            field_dict["limits"] = limits
+        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:
+        from ..models.error_details import ErrorDetails  # noqa: PLC0415
+        from ..models.upload_limits import UploadLimits  # noqa: PLC0415
+
+        d = dict(src_dict)
+        error = d.pop("error")
+
+        code = d.pop("code")
+
+        needed_seconds = d.pop("needed_seconds", UNSET)
+
+        balance_seconds = d.pop("balance_seconds", UNSET)
+
+        held_seconds = d.pop("held_seconds", UNSET)
+
+        org_balance_seconds = d.pop("org_balance_seconds", UNSET)
+
+        _limits = d.pop("limits", UNSET)
+        limits: UploadLimits | Unset
+        if isinstance(_limits, Unset):
+            limits = UNSET
+        else:
+            limits = UploadLimits.from_dict(_limits)
+
+        _details = d.pop("details", UNSET)
+        details: ErrorDetails | Unset
+        if isinstance(_details, Unset):
+            details = UNSET
+        else:
+            details = ErrorDetails.from_dict(_details)
+
+        error = cls(
+            error=error,
+            code=code,
+            needed_seconds=needed_seconds,
+            balance_seconds=balance_seconds,
+            held_seconds=held_seconds,
+            org_balance_seconds=org_balance_seconds,
+            limits=limits,
+            details=details,
+        )
+
+        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

hushscript/generated/models/error_details.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ErrorDetails")
+
+
+@_attrs_define
+class ErrorDetails:
+    """Structured recovery detail for an error that is not a plain balance shortfall. Present on agent_pack_locked and
+    agent_purchase_capped.
+
+        Attributes:
+            allowed_packs (list[str] | Unset): Pack ids the agent account may buy right now. Present on agent_pack_locked;
+                retry with one of these.
+            limit (int | Unset): The per-credential purchase cap for the rolling window. Present on agent_purchase_capped.
+            window_seconds (int | Unset): The length of the rolling window in seconds. Present on agent_purchase_capped.
+            retry_after_seconds (int | Unset): Seconds until the oldest purchase counted toward the cap leaves the window.
+                Present on agent_purchase_capped; matches the Retry-After header.
+    """
+
+    allowed_packs: list[str] | Unset = UNSET
+    limit: int | Unset = UNSET
+    window_seconds: int | Unset = UNSET
+    retry_after_seconds: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        allowed_packs: list[str] | Unset = UNSET
+        if not isinstance(self.allowed_packs, Unset):
+            allowed_packs = self.allowed_packs
+
+        limit = self.limit
+
+        window_seconds = self.window_seconds
+
+        retry_after_seconds = self.retry_after_seconds
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if allowed_packs is not UNSET:
+            field_dict["allowed_packs"] = allowed_packs
+        if limit is not UNSET:
+            field_dict["limit"] = limit
+        if window_seconds is not UNSET:
+            field_dict["window_seconds"] = window_seconds
+        if retry_after_seconds is not UNSET:
+            field_dict["retry_after_seconds"] = retry_after_seconds
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        allowed_packs = cast(list[str], d.pop("allowed_packs", UNSET))
+
+        limit = d.pop("limit", UNSET)
+
+        window_seconds = d.pop("window_seconds", UNSET)
+
+        retry_after_seconds = d.pop("retry_after_seconds", UNSET)
+
+        error_details = cls(
+            allowed_packs=allowed_packs,
+            limit=limit,
+            window_seconds=window_seconds,
+            retry_after_seconds=retry_after_seconds,
+        )
+
+        error_details.additional_properties = d
+        return error_details
+
+    @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

hushscript/generated/models/get_upload_part_urls_response_200_type_0.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.presigned_part_url import PresignedPartUrl
+
+
+T = TypeVar("T", bound="GetUploadPartUrlsResponse200Type0")
+
+
+@_attrs_define
+class GetUploadPartUrlsResponse200Type0:
+    """One page of presigned direct-to-R2 PUT URLs, or null when direct-to-R2 uploads are not available for this job and
+    parts must be sent to upload_part instead.
+
+        Attributes:
+            part_size_bytes (int): The byte size of every part except the last.
+            total_parts (int): The total number of parts this upload is split into.
+            part_urls (list[PresignedPartUrl]): Presigned URLs for this page's parts, starting at the requested (or first)
+                part number.
+            next_part_number (int | None): The next part number not covered by this page, or null once every part has a URL.
+    """
+
+    part_size_bytes: int
+    total_parts: int
+    part_urls: list[PresignedPartUrl]
+    next_part_number: int | None
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        part_size_bytes = self.part_size_bytes
+
+        total_parts = self.total_parts
+
+        part_urls = []
+        for part_urls_item_data in self.part_urls:
+            part_urls_item = part_urls_item_data.to_dict()
+            part_urls.append(part_urls_item)
+
+        next_part_number: int | None
+        next_part_number = self.next_part_number
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "part_size_bytes": part_size_bytes,
+                "total_parts": total_parts,
+                "part_urls": part_urls,
+                "next_part_number": next_part_number,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.presigned_part_url import PresignedPartUrl  # noqa: PLC0415
+
+        d = dict(src_dict)
+        part_size_bytes = d.pop("part_size_bytes")
+
+        total_parts = d.pop("total_parts")
+
+        part_urls = []
+        _part_urls = d.pop("part_urls")
+        for part_urls_item_data in _part_urls:
+            part_urls_item = PresignedPartUrl.from_dict(part_urls_item_data)
+
+            part_urls.append(part_urls_item)
+
+        def _parse_next_part_number(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        next_part_number = _parse_next_part_number(d.pop("next_part_number"))
+
+        get_upload_part_urls_response_200_type_0 = cls(
+            part_size_bytes=part_size_bytes,
+            total_parts=total_parts,
+            part_urls=part_urls,
+            next_part_number=next_part_number,
+        )
+
+        get_upload_part_urls_response_200_type_0.additional_properties = d
+        return get_upload_part_urls_response_200_type_0
+
+    @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

hushscript/generated/models/heartbeat_upload_response_200.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+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="HeartbeatUploadResponse200")
+
+
+@_attrs_define
+class HeartbeatUploadResponse200:
+    """
+    Attributes:
+        ok (bool):
+    """
+
+    ok: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        ok = self.ok
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "ok": ok,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        heartbeat_upload_response_200 = cls(
+            ok=ok,
+        )
+
+        heartbeat_upload_response_200.additional_properties = d
+        return heartbeat_upload_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

hushscript/generated/models/holds_response.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.active_hold import ActiveHold
+
+
+T = TypeVar("T", bound="HoldsResponse")
+
+
+@_attrs_define
+class HoldsResponse:
+    """
+    Attributes:
+        holds (list[ActiveHold]):
+        next_cursor (None | str): An opaque token for the next page's cursor parameter, or null on the last page. This
+            API refuses a cursor it did not mint.
+    """
+
+    holds: list[ActiveHold]
+    next_cursor: None | str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        holds = []
+        for holds_item_data in self.holds:
+            holds_item = holds_item_data.to_dict()
+            holds.append(holds_item)
+
+        next_cursor: None | str
+        next_cursor = self.next_cursor
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "holds": holds,
+                "next_cursor": next_cursor,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.active_hold import ActiveHold  # noqa: PLC0415
+
+        d = dict(src_dict)
+        holds = []
+        _holds = d.pop("holds")
+        for holds_item_data in _holds:
+            holds_item = ActiveHold.from_dict(holds_item_data)
+
+            holds.append(holds_item)
+
+        def _parse_next_cursor(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        next_cursor = _parse_next_cursor(d.pop("next_cursor"))
+
+        holds_response = cls(
+            holds=holds,
+            next_cursor=next_cursor,
+        )
+
+        holds_response.additional_properties = d
+        return holds_response
+
+    @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