hushscript 1.0.0__py3-none-any.whl

hushscript/generated/models/transcript_list_row.py

@@ -0,0 +1,152 @@
+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 ..models.transcript_list_row_insights_state import (
+    TranscriptListRowInsightsState,
+    check_transcript_list_row_insights_state,
+)
+
+if TYPE_CHECKING:
+    from ..models.options_summary import OptionsSummary
+
+
+T = TypeVar("T", bound="TranscriptListRow")
+
+
+@_attrs_define
+class TranscriptListRow:
+    """
+    Attributes:
+        id (str):
+        title (str):
+        language_detected (None | str):
+        duration_seconds (int):
+        created_at (int):
+        auto_delete_at (int | None):
+        tags (list[str]):
+        options (OptionsSummary): A content-free summary of the transcription options a job was submitted with: what was
+            requested, never the free-text content itself.
+        insights_state (TranscriptListRowInsightsState): A display hint only, never an authority on whether Insights may
+            be generated or charged for.
+    """
+
+    id: str
+    title: str
+    language_detected: None | str
+    duration_seconds: int
+    created_at: int
+    auto_delete_at: int | None
+    tags: list[str]
+    options: OptionsSummary
+    insights_state: TranscriptListRowInsightsState
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        title = self.title
+
+        language_detected: None | str
+        language_detected = self.language_detected
+
+        duration_seconds = self.duration_seconds
+
+        created_at = self.created_at
+
+        auto_delete_at: int | None
+        auto_delete_at = self.auto_delete_at
+
+        tags = self.tags
+
+        options = self.options.to_dict()
+
+        insights_state: str = self.insights_state
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "title": title,
+                "language_detected": language_detected,
+                "duration_seconds": duration_seconds,
+                "created_at": created_at,
+                "auto_delete_at": auto_delete_at,
+                "tags": tags,
+                "options": options,
+                "insights_state": insights_state,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.options_summary import OptionsSummary  # noqa: PLC0415
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        title = d.pop("title")
+
+        def _parse_language_detected(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        language_detected = _parse_language_detected(d.pop("language_detected"))
+
+        duration_seconds = d.pop("duration_seconds")
+
+        created_at = d.pop("created_at")
+
+        def _parse_auto_delete_at(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        auto_delete_at = _parse_auto_delete_at(d.pop("auto_delete_at"))
+
+        tags = cast(list[str], d.pop("tags"))
+
+        options = OptionsSummary.from_dict(d.pop("options"))
+
+        insights_state = check_transcript_list_row_insights_state(
+            d.pop("insights_state")
+        )
+
+        transcript_list_row = cls(
+            id=id,
+            title=title,
+            language_detected=language_detected,
+            duration_seconds=duration_seconds,
+            created_at=created_at,
+            auto_delete_at=auto_delete_at,
+            tags=tags,
+            options=options,
+            insights_state=insights_state,
+        )
+
+        transcript_list_row.additional_properties = d
+        return transcript_list_row
+
+    @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/transcript_list_row_insights_state.py

@@ -0,0 +1,20 @@
+from typing import Literal
+
+TranscriptListRowInsightsState = Literal["failed", "generating", "none", "ready"]
+
+TRANSCRIPT_LIST_ROW_INSIGHTS_STATE_VALUES: set[TranscriptListRowInsightsState] = {
+    "failed",
+    "generating",
+    "none",
+    "ready",
+}
+
+
+def check_transcript_list_row_insights_state(
+    value: str,
+) -> TranscriptListRowInsightsState:
+    if value in TRANSCRIPT_LIST_ROW_INSIGHTS_STATE_VALUES:
+        return value
+    raise TypeError(
+        f"Unexpected value {value!r}. Expected one of {TRANSCRIPT_LIST_ROW_INSIGHTS_STATE_VALUES!r}"
+    )

hushscript/generated/models/transcription_context_response.py

@@ -0,0 +1,95 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.context_dictionary import ContextDictionary
+    from ..models.context_prompt_preset import ContextPromptPreset
+
+
+T = TypeVar("T", bound="TranscriptionContextResponse")
+
+
+@_attrs_define
+class TranscriptionContextResponse:
+    """Not paginated and carrying no cursor: both collections are capped when they are written (50 dictionaries, 20 prompt
+    presets), so this response is always complete.
+
+        Attributes:
+            dictionaries (list[ContextDictionary]):
+            prompts (list[ContextPromptPreset]):
+    """
+
+    dictionaries: list[ContextDictionary]
+    prompts: list[ContextPromptPreset]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        dictionaries = []
+        for dictionaries_item_data in self.dictionaries:
+            dictionaries_item = dictionaries_item_data.to_dict()
+            dictionaries.append(dictionaries_item)
+
+        prompts = []
+        for prompts_item_data in self.prompts:
+            prompts_item = prompts_item_data.to_dict()
+            prompts.append(prompts_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "dictionaries": dictionaries,
+                "prompts": prompts,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.context_dictionary import ContextDictionary  # noqa: PLC0415
+        from ..models.context_prompt_preset import ContextPromptPreset  # noqa: PLC0415
+
+        d = dict(src_dict)
+        dictionaries = []
+        _dictionaries = d.pop("dictionaries")
+        for dictionaries_item_data in _dictionaries:
+            dictionaries_item = ContextDictionary.from_dict(dictionaries_item_data)
+
+            dictionaries.append(dictionaries_item)
+
+        prompts = []
+        _prompts = d.pop("prompts")
+        for prompts_item_data in _prompts:
+            prompts_item = ContextPromptPreset.from_dict(prompts_item_data)
+
+            prompts.append(prompts_item)
+
+        transcription_context_response = cls(
+            dictionaries=dictionaries,
+            prompts=prompts,
+        )
+
+        transcription_context_response.additional_properties = d
+        return transcription_context_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

hushscript/generated/models/upload_complete_response.py

@@ -0,0 +1,100 @@
+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
+
+T = TypeVar("T", bound="UploadCompleteResponse")
+
+
+@_attrs_define
+class UploadCompleteResponse:
+    """
+    Attributes:
+        ok (bool):
+        state (str): The job's state immediately after completion, e.g. queued, processing or done.
+        verified_seconds (int | None): The probed exact duration, once verification has run; null while verification is
+            still pending.
+        balance_seconds (int): The account's net balance after the hold was reconciled to the verified duration.
+        held_seconds (int):
+    """
+
+    ok: bool
+    state: str
+    verified_seconds: int | None
+    balance_seconds: int
+    held_seconds: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        ok = self.ok
+
+        state = self.state
+
+        verified_seconds: int | None
+        verified_seconds = self.verified_seconds
+
+        balance_seconds = self.balance_seconds
+
+        held_seconds = self.held_seconds
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "ok": ok,
+                "state": state,
+                "verified_seconds": verified_seconds,
+                "balance_seconds": balance_seconds,
+                "held_seconds": held_seconds,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        state = d.pop("state")
+
+        def _parse_verified_seconds(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        verified_seconds = _parse_verified_seconds(d.pop("verified_seconds"))
+
+        balance_seconds = d.pop("balance_seconds")
+
+        held_seconds = d.pop("held_seconds")
+
+        upload_complete_response = cls(
+            ok=ok,
+            state=state,
+            verified_seconds=verified_seconds,
+            balance_seconds=balance_seconds,
+            held_seconds=held_seconds,
+        )
+
+        upload_complete_response.additional_properties = d
+        return upload_complete_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

hushscript/generated/models/upload_create_response.py

@@ -0,0 +1,148 @@
+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 ..models.upload_create_response_funding import (
+    UploadCreateResponseFunding,
+    check_upload_create_response_funding,
+)
+
+if TYPE_CHECKING:
+    from ..models.upload_create_response_upload_type_0 import (
+        UploadCreateResponseUploadType0,
+    )
+    from ..models.upload_limits import UploadLimits
+
+
+T = TypeVar("T", bound="UploadCreateResponse")
+
+
+@_attrs_define
+class UploadCreateResponse:
+    """
+    Attributes:
+        job_id (str):
+        balance_seconds (int): The account's net balance after this upload's hold was placed.
+        held_seconds (int):
+        limits (UploadLimits): The caller's current upload admission limits, shared by every response that carries them.
+        upload (None | UploadCreateResponseUploadType0): 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.
+        funding (UploadCreateResponseFunding): Which balance this upload's hold was placed against.
+        state (str): The job's initial state, typically uploading.
+    """
+
+    job_id: str
+    balance_seconds: int
+    held_seconds: int
+    limits: UploadLimits
+    upload: None | UploadCreateResponseUploadType0
+    funding: UploadCreateResponseFunding
+    state: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.upload_create_response_upload_type_0 import (
+            UploadCreateResponseUploadType0,  # noqa: PLC0415
+        )
+
+        job_id = self.job_id
+
+        balance_seconds = self.balance_seconds
+
+        held_seconds = self.held_seconds
+
+        limits = self.limits.to_dict()
+
+        upload: dict[str, Any] | None
+        if isinstance(self.upload, UploadCreateResponseUploadType0):
+            upload = self.upload.to_dict()
+        else:
+            upload = self.upload
+
+        funding: str = self.funding
+
+        state = self.state
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "job_id": job_id,
+                "balance_seconds": balance_seconds,
+                "held_seconds": held_seconds,
+                "limits": limits,
+                "upload": upload,
+                "funding": funding,
+                "state": state,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.upload_create_response_upload_type_0 import (
+            UploadCreateResponseUploadType0,  # noqa: PLC0415
+        )
+        from ..models.upload_limits import UploadLimits  # noqa: PLC0415
+
+        d = dict(src_dict)
+        job_id = d.pop("job_id")
+
+        balance_seconds = d.pop("balance_seconds")
+
+        held_seconds = d.pop("held_seconds")
+
+        limits = UploadLimits.from_dict(d.pop("limits"))
+
+        def _parse_upload(data: object) -> None | UploadCreateResponseUploadType0:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                upload_type_0 = UploadCreateResponseUploadType0.from_dict(data)
+
+                return upload_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | UploadCreateResponseUploadType0, data)
+
+        upload = _parse_upload(d.pop("upload"))
+
+        funding = check_upload_create_response_funding(d.pop("funding"))
+
+        state = d.pop("state")
+
+        upload_create_response = cls(
+            job_id=job_id,
+            balance_seconds=balance_seconds,
+            held_seconds=held_seconds,
+            limits=limits,
+            upload=upload,
+            funding=funding,
+            state=state,
+        )
+
+        upload_create_response.additional_properties = d
+        return upload_create_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

hushscript/generated/models/upload_create_response_funding.py

@@ -0,0 +1,16 @@
+from typing import Literal
+
+UploadCreateResponseFunding = Literal["org", "personal"]
+
+UPLOAD_CREATE_RESPONSE_FUNDING_VALUES: set[UploadCreateResponseFunding] = {
+    "org",
+    "personal",
+}
+
+
+def check_upload_create_response_funding(value: str) -> UploadCreateResponseFunding:
+    if value in UPLOAD_CREATE_RESPONSE_FUNDING_VALUES:
+        return value
+    raise TypeError(
+        f"Unexpected value {value!r}. Expected one of {UPLOAD_CREATE_RESPONSE_FUNDING_VALUES!r}"
+    )

hushscript/generated/models/upload_create_response_upload_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="UploadCreateResponseUploadType0")
+
+
+@_attrs_define
+class UploadCreateResponseUploadType0:
+    """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"))
+
+        upload_create_response_upload_type_0 = cls(
+            part_size_bytes=part_size_bytes,
+            total_parts=total_parts,
+            part_urls=part_urls,
+            next_part_number=next_part_number,
+        )
+
+        upload_create_response_upload_type_0.additional_properties = d
+        return upload_create_response_upload_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