hushscript 1.0.0__py3-none-any.whl

hushscript/generated/models/complete_upload_body.py

@@ -0,0 +1,107 @@
+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
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.complete_upload_body_parts_type_0_item import (
+        CompleteUploadBodyPartsType0Item,
+    )
+
+
+T = TypeVar("T", bound="CompleteUploadBody")
+
+
+@_attrs_define
+class CompleteUploadBody:
+    """
+    Attributes:
+        parts (list[CompleteUploadBodyPartsType0Item] | None | Unset): The part number and ETag of every part a direct-
+            to-R2 client uploaded. Omit entirely for a worker-uploaded job.
+    """
+
+    parts: list[CompleteUploadBodyPartsType0Item] | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        parts: list[dict[str, Any]] | None | Unset
+        if isinstance(self.parts, Unset):
+            parts = UNSET
+        elif isinstance(self.parts, list):
+            parts = []
+            for parts_type_0_item_data in self.parts:
+                parts_type_0_item = parts_type_0_item_data.to_dict()
+                parts.append(parts_type_0_item)
+
+        else:
+            parts = self.parts
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if parts is not UNSET:
+            field_dict["parts"] = parts
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.complete_upload_body_parts_type_0_item import (
+            CompleteUploadBodyPartsType0Item,  # noqa: PLC0415
+        )
+
+        d = dict(src_dict)
+
+        def _parse_parts(
+            data: object,
+        ) -> list[CompleteUploadBodyPartsType0Item] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                parts_type_0 = []
+                _parts_type_0 = data
+                for parts_type_0_item_data in _parts_type_0:
+                    parts_type_0_item = CompleteUploadBodyPartsType0Item.from_dict(
+                        parts_type_0_item_data
+                    )
+
+                    parts_type_0.append(parts_type_0_item)
+
+                return parts_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[CompleteUploadBodyPartsType0Item] | None | Unset, data)
+
+        parts = _parse_parts(d.pop("parts", UNSET))
+
+        complete_upload_body = cls(
+            parts=parts,
+        )
+
+        complete_upload_body.additional_properties = d
+        return complete_upload_body
+
+    @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/complete_upload_body_parts_type_0_item.py

@@ -0,0 +1,69 @@
+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="CompleteUploadBodyPartsType0Item")
+
+
+@_attrs_define
+class CompleteUploadBodyPartsType0Item:
+    """
+    Attributes:
+        n (int):
+        etag (str):
+    """
+
+    n: int
+    etag: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        n = self.n
+
+        etag = self.etag
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "n": n,
+                "etag": etag,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        n = d.pop("n")
+
+        etag = d.pop("etag")
+
+        complete_upload_body_parts_type_0_item = cls(
+            n=n,
+            etag=etag,
+        )
+
+        complete_upload_body_parts_type_0_item.additional_properties = d
+        return complete_upload_body_parts_type_0_item
+
+    @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/context_dictionary.py

@@ -0,0 +1,143 @@
+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.dictionary_entry import DictionaryEntry
+
+
+T = TypeVar("T", bound="ContextDictionary")
+
+
+@_attrs_define
+class ContextDictionary:
+    """
+    Attributes:
+        id (str):
+        name (str):
+        description (str): Free-text description. Empty when unset; never null.
+        language_code (str): The language this applies to: all, or one of the supported source language codes. Never
+            empty and never null: unset is stored as all.
+        entries (list[DictionaryEntry]):
+        terms (list[str]): The flat recognition terms this dictionary compiles into. Derived from entries when entries
+            exist (every canonical spelling and its variants, deduplicated); otherwise the legacy flat list stored before
+            entries existed.
+        is_default (bool): Whether this dictionary is applied to an upload that selects none explicitly. At most one
+            dictionary is the default.
+        created_at (int):
+        updated_at (int):
+    """
+
+    id: str
+    name: str
+    description: str
+    language_code: str
+    entries: list[DictionaryEntry]
+    terms: list[str]
+    is_default: bool
+    created_at: int
+    updated_at: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        name = self.name
+
+        description = self.description
+
+        language_code = self.language_code
+
+        entries = []
+        for entries_item_data in self.entries:
+            entries_item = entries_item_data.to_dict()
+            entries.append(entries_item)
+
+        terms = self.terms
+
+        is_default = self.is_default
+
+        created_at = self.created_at
+
+        updated_at = self.updated_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "name": name,
+                "description": description,
+                "language_code": language_code,
+                "entries": entries,
+                "terms": terms,
+                "is_default": is_default,
+                "created_at": created_at,
+                "updated_at": updated_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.dictionary_entry import DictionaryEntry  # noqa: PLC0415
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        name = d.pop("name")
+
+        description = d.pop("description")
+
+        language_code = d.pop("language_code")
+
+        entries = []
+        _entries = d.pop("entries")
+        for entries_item_data in _entries:
+            entries_item = DictionaryEntry.from_dict(entries_item_data)
+
+            entries.append(entries_item)
+
+        terms = cast(list[str], d.pop("terms"))
+
+        is_default = d.pop("is_default")
+
+        created_at = d.pop("created_at")
+
+        updated_at = d.pop("updated_at")
+
+        context_dictionary = cls(
+            id=id,
+            name=name,
+            description=description,
+            language_code=language_code,
+            entries=entries,
+            terms=terms,
+            is_default=is_default,
+            created_at=created_at,
+            updated_at=updated_at,
+        )
+
+        context_dictionary.additional_properties = d
+        return context_dictionary
+
+    @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/context_prompt_preset.py

@@ -0,0 +1,118 @@
+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="ContextPromptPreset")
+
+
+@_attrs_define
+class ContextPromptPreset:
+    """
+    Attributes:
+        id (str):
+        name (str):
+        description (str): Free-text description. Empty when unset; never null.
+        language_code (str): The language this applies to: all, or one of the supported source language codes. Never
+            empty and never null: unset is stored as all.
+        body (str):
+        is_default (bool):
+        created_at (int):
+        updated_at (int):
+    """
+
+    id: str
+    name: str
+    description: str
+    language_code: str
+    body: str
+    is_default: bool
+    created_at: int
+    updated_at: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        name = self.name
+
+        description = self.description
+
+        language_code = self.language_code
+
+        body = self.body
+
+        is_default = self.is_default
+
+        created_at = self.created_at
+
+        updated_at = self.updated_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "name": name,
+                "description": description,
+                "language_code": language_code,
+                "body": body,
+                "is_default": is_default,
+                "created_at": created_at,
+                "updated_at": updated_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        name = d.pop("name")
+
+        description = d.pop("description")
+
+        language_code = d.pop("language_code")
+
+        body = d.pop("body")
+
+        is_default = d.pop("is_default")
+
+        created_at = d.pop("created_at")
+
+        updated_at = d.pop("updated_at")
+
+        context_prompt_preset = cls(
+            id=id,
+            name=name,
+            description=description,
+            language_code=language_code,
+            body=body,
+            is_default=is_default,
+            created_at=created_at,
+            updated_at=updated_at,
+        )
+
+        context_prompt_preset.additional_properties = d
+        return context_prompt_preset
+
+    @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/create_setup_session_body.py

@@ -0,0 +1,62 @@
+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
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CreateSetupSessionBody")
+
+
+@_attrs_define
+class CreateSetupSessionBody:
+    """
+    Attributes:
+        idempotency_key (str | Unset): Optional client-minted key so a retried request reuses one Session instead of
+            opening a new one. Omit it for a fresh Session on every call.
+    """
+
+    idempotency_key: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        idempotency_key = self.idempotency_key
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if idempotency_key is not UNSET:
+            field_dict["idempotency_key"] = idempotency_key
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        idempotency_key = d.pop("idempotency_key", UNSET)
+
+        create_setup_session_body = cls(
+            idempotency_key=idempotency_key,
+        )
+
+        create_setup_session_body.additional_properties = d
+        return create_setup_session_body
+
+    @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