hushscript 1.0.0__py3-none-any.whl

hushscript/generated/models/create_upload_body.py

@@ -0,0 +1,254 @@
+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.create_upload_body_transcription_options_type_0 import (
+        CreateUploadBodyTranscriptionOptionsType0,
+    )
+
+
+T = TypeVar("T", bound="CreateUploadBody")
+
+
+@_attrs_define
+class CreateUploadBody:
+    """
+    Attributes:
+        size_bytes (int): The exact declared byte size of the audio file, up to the 5 GB cap.
+        duration_seconds (int): The declared duration in seconds, from 15 seconds up to the 10 hour cap. Rechecked
+            against the probed exact duration at complete_upload.
+        title (None | str | Unset): An optional display title. A value longer than 300 bytes is truncated on a character
+            boundary rather than rejected, and this response does not echo the stored value; read it back from the
+            transcript once the job completes. In `private` mode the title is not stored at all.
+        mode (None | str | Unset): Optional job mode, e.g. a private-result upload.
+        part_size_bytes (int | None | Unset): Optional smaller part size for a flaky connection. Clamped to this API's
+            supported range; omit for the 32 MiB default.
+        idempotency_key (None | str | Unset): An optional client-minted key, 16 to 128 bytes. Resending the same key
+            returns the same job with no second hold.
+        matter_code (None | str | Unset): Free text, trimmed, at most 64 characters; blank is valid and clears it.
+            Refused with org_matter_code_required when the caller's workspace sets matter_code_policy to required and this
+            is absent or blank.
+        client_code (None | str | Unset): Free text, trimmed, at most 64 characters; blank is valid. Accepted for
+            backward compatibility: for an org caller the client is always resolved from the matter instead, never from this
+            field.
+        transcription_options (CreateUploadBodyTranscriptionOptionsType0 | None | Unset):
+    """
+
+    size_bytes: int
+    duration_seconds: int
+    title: None | str | Unset = UNSET
+    mode: None | str | Unset = UNSET
+    part_size_bytes: int | None | Unset = UNSET
+    idempotency_key: None | str | Unset = UNSET
+    matter_code: None | str | Unset = UNSET
+    client_code: None | str | Unset = UNSET
+    transcription_options: CreateUploadBodyTranscriptionOptionsType0 | None | Unset = (
+        UNSET
+    )
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.create_upload_body_transcription_options_type_0 import (
+            CreateUploadBodyTranscriptionOptionsType0,  # noqa: PLC0415
+        )
+
+        size_bytes = self.size_bytes
+
+        duration_seconds = self.duration_seconds
+
+        title: None | str | Unset
+        if isinstance(self.title, Unset):
+            title = UNSET
+        else:
+            title = self.title
+
+        mode: None | str | Unset
+        if isinstance(self.mode, Unset):
+            mode = UNSET
+        else:
+            mode = self.mode
+
+        part_size_bytes: int | None | Unset
+        if isinstance(self.part_size_bytes, Unset):
+            part_size_bytes = UNSET
+        else:
+            part_size_bytes = self.part_size_bytes
+
+        idempotency_key: None | str | Unset
+        if isinstance(self.idempotency_key, Unset):
+            idempotency_key = UNSET
+        else:
+            idempotency_key = self.idempotency_key
+
+        matter_code: None | str | Unset
+        if isinstance(self.matter_code, Unset):
+            matter_code = UNSET
+        else:
+            matter_code = self.matter_code
+
+        client_code: None | str | Unset
+        if isinstance(self.client_code, Unset):
+            client_code = UNSET
+        else:
+            client_code = self.client_code
+
+        transcription_options: dict[str, Any] | None | Unset
+        if isinstance(self.transcription_options, Unset):
+            transcription_options = UNSET
+        elif isinstance(
+            self.transcription_options, CreateUploadBodyTranscriptionOptionsType0
+        ):
+            transcription_options = self.transcription_options.to_dict()
+        else:
+            transcription_options = self.transcription_options
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "size_bytes": size_bytes,
+                "duration_seconds": duration_seconds,
+            }
+        )
+        if title is not UNSET:
+            field_dict["title"] = title
+        if mode is not UNSET:
+            field_dict["mode"] = mode
+        if part_size_bytes is not UNSET:
+            field_dict["part_size_bytes"] = part_size_bytes
+        if idempotency_key is not UNSET:
+            field_dict["idempotency_key"] = idempotency_key
+        if matter_code is not UNSET:
+            field_dict["matter_code"] = matter_code
+        if client_code is not UNSET:
+            field_dict["client_code"] = client_code
+        if transcription_options is not UNSET:
+            field_dict["transcription_options"] = transcription_options
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.create_upload_body_transcription_options_type_0 import (
+            CreateUploadBodyTranscriptionOptionsType0,  # noqa: PLC0415
+        )
+
+        d = dict(src_dict)
+        size_bytes = d.pop("size_bytes")
+
+        duration_seconds = d.pop("duration_seconds")
+
+        def _parse_title(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        title = _parse_title(d.pop("title", UNSET))
+
+        def _parse_mode(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        mode = _parse_mode(d.pop("mode", UNSET))
+
+        def _parse_part_size_bytes(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        part_size_bytes = _parse_part_size_bytes(d.pop("part_size_bytes", UNSET))
+
+        def _parse_idempotency_key(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        idempotency_key = _parse_idempotency_key(d.pop("idempotency_key", UNSET))
+
+        def _parse_matter_code(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        matter_code = _parse_matter_code(d.pop("matter_code", UNSET))
+
+        def _parse_client_code(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        client_code = _parse_client_code(d.pop("client_code", UNSET))
+
+        def _parse_transcription_options(
+            data: object,
+        ) -> CreateUploadBodyTranscriptionOptionsType0 | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                transcription_options_type_0 = (
+                    CreateUploadBodyTranscriptionOptionsType0.from_dict(data)
+                )
+
+                return transcription_options_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(CreateUploadBodyTranscriptionOptionsType0 | None | Unset, data)
+
+        transcription_options = _parse_transcription_options(
+            d.pop("transcription_options", UNSET)
+        )
+
+        create_upload_body = cls(
+            size_bytes=size_bytes,
+            duration_seconds=duration_seconds,
+            title=title,
+            mode=mode,
+            part_size_bytes=part_size_bytes,
+            idempotency_key=idempotency_key,
+            matter_code=matter_code,
+            client_code=client_code,
+            transcription_options=transcription_options,
+        )
+
+        create_upload_body.additional_properties = d
+        return create_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/create_upload_body_transcription_options_type_0.py

@@ -0,0 +1,178 @@
+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="CreateUploadBodyTranscriptionOptionsType0")
+
+
+@_attrs_define
+class CreateUploadBodyTranscriptionOptionsType0:
+    """Transcription options for this job. Every field is optional; omitting the object requests the account's default
+    behaviour (language auto-detection and speaker labels on).
+
+        Attributes:
+            language_code (None | str | Unset): Force a specific spoken language instead of auto-detection.
+            speaker_detection (bool | Unset): Label distinct speakers in the transcript. Forced on automatically when
+                translation_targets is non-empty.
+            keyterms_prompt (list[str] | Unset): Domain vocabulary to bias transcription toward, up to 1000 terms of at most
+                6 words each.
+            prompt (None | str | Unset): Free-text context to bias transcription toward.
+            medical_mode (bool | Unset): Bill and transcribe as a medical dictation. Requires language_code to be one of en,
+                es, fr, de; billed at a 100 percent surcharge on the duration.
+            multichannel (bool | Unset): Transcribe each audio channel independently. Billed per channel: a stereo file
+                counts twice, a 3-channel file three times, up to 8 channels, and the medical surcharge applies on top of that;
+                translation targets stay on a single duration. The channel count is the most channels any audio track of the
+                file carries. A file with more than 8 channels, or one whose channel count cannot be read, falls back to mixed
+                audio with speaker labels and is billed once. Without this option the file is transcribed as one mixed channel
+                and billed once. The initial hold at upload creation is for a single channel; verification raises it to the per-
+                channel amount and fails the job with insufficient_balance if the balance cannot cover it.
+            translation_targets (list[str] | Unset): Locales to additionally translate the transcript into. Each target adds
+                a 25 percent surcharge on the duration and forces speaker_detection on.
+            auto_generate_insights (bool | None | Unset): Override the account's automatic-Insights default for this upload
+                alone. Omit to inherit the account default; an explicit false always suppresses automatic generation for this
+                upload.
+    """
+
+    language_code: None | str | Unset = UNSET
+    speaker_detection: bool | Unset = UNSET
+    keyterms_prompt: list[str] | Unset = UNSET
+    prompt: None | str | Unset = UNSET
+    medical_mode: bool | Unset = UNSET
+    multichannel: bool | Unset = UNSET
+    translation_targets: list[str] | Unset = UNSET
+    auto_generate_insights: bool | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        language_code: None | str | Unset
+        if isinstance(self.language_code, Unset):
+            language_code = UNSET
+        else:
+            language_code = self.language_code
+
+        speaker_detection = self.speaker_detection
+
+        keyterms_prompt: list[str] | Unset = UNSET
+        if not isinstance(self.keyterms_prompt, Unset):
+            keyterms_prompt = self.keyterms_prompt
+
+        prompt: None | str | Unset
+        if isinstance(self.prompt, Unset):
+            prompt = UNSET
+        else:
+            prompt = self.prompt
+
+        medical_mode = self.medical_mode
+
+        multichannel = self.multichannel
+
+        translation_targets: list[str] | Unset = UNSET
+        if not isinstance(self.translation_targets, Unset):
+            translation_targets = self.translation_targets
+
+        auto_generate_insights: bool | None | Unset
+        if isinstance(self.auto_generate_insights, Unset):
+            auto_generate_insights = UNSET
+        else:
+            auto_generate_insights = self.auto_generate_insights
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if language_code is not UNSET:
+            field_dict["language_code"] = language_code
+        if speaker_detection is not UNSET:
+            field_dict["speaker_detection"] = speaker_detection
+        if keyterms_prompt is not UNSET:
+            field_dict["keyterms_prompt"] = keyterms_prompt
+        if prompt is not UNSET:
+            field_dict["prompt"] = prompt
+        if medical_mode is not UNSET:
+            field_dict["medical_mode"] = medical_mode
+        if multichannel is not UNSET:
+            field_dict["multichannel"] = multichannel
+        if translation_targets is not UNSET:
+            field_dict["translation_targets"] = translation_targets
+        if auto_generate_insights is not UNSET:
+            field_dict["auto_generate_insights"] = auto_generate_insights
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_language_code(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        language_code = _parse_language_code(d.pop("language_code", UNSET))
+
+        speaker_detection = d.pop("speaker_detection", UNSET)
+
+        keyterms_prompt = cast(list[str], d.pop("keyterms_prompt", UNSET))
+
+        def _parse_prompt(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        prompt = _parse_prompt(d.pop("prompt", UNSET))
+
+        medical_mode = d.pop("medical_mode", UNSET)
+
+        multichannel = d.pop("multichannel", UNSET)
+
+        translation_targets = cast(list[str], d.pop("translation_targets", UNSET))
+
+        def _parse_auto_generate_insights(data: object) -> bool | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(bool | None | Unset, data)
+
+        auto_generate_insights = _parse_auto_generate_insights(
+            d.pop("auto_generate_insights", UNSET)
+        )
+
+        create_upload_body_transcription_options_type_0 = cls(
+            language_code=language_code,
+            speaker_detection=speaker_detection,
+            keyterms_prompt=keyterms_prompt,
+            prompt=prompt,
+            medical_mode=medical_mode,
+            multichannel=multichannel,
+            translation_targets=translation_targets,
+            auto_generate_insights=auto_generate_insights,
+        )
+
+        create_upload_body_transcription_options_type_0.additional_properties = d
+        return create_upload_body_transcription_options_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/credit_ledger_entry.py

@@ -0,0 +1,113 @@
+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="CreditLedgerEntry")
+
+
+@_attrs_define
+class CreditLedgerEntry:
+    """
+    Attributes:
+        id (int):
+        delta_seconds (int):
+        kind (str):
+        job_id (None | str):
+        note (None | str):
+        created_at (int):
+    """
+
+    id: int
+    delta_seconds: int
+    kind: str
+    job_id: None | str
+    note: None | str
+    created_at: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        delta_seconds = self.delta_seconds
+
+        kind = self.kind
+
+        job_id: None | str
+        job_id = self.job_id
+
+        note: None | str
+        note = self.note
+
+        created_at = self.created_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "delta_seconds": delta_seconds,
+                "kind": kind,
+                "job_id": job_id,
+                "note": note,
+                "created_at": created_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")
+
+        delta_seconds = d.pop("delta_seconds")
+
+        kind = d.pop("kind")
+
+        def _parse_job_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        job_id = _parse_job_id(d.pop("job_id"))
+
+        def _parse_note(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        note = _parse_note(d.pop("note"))
+
+        created_at = d.pop("created_at")
+
+        credit_ledger_entry = cls(
+            id=id,
+            delta_seconds=delta_seconds,
+            kind=kind,
+            job_id=job_id,
+            note=note,
+            created_at=created_at,
+        )
+
+        credit_ledger_entry.additional_properties = d
+        return credit_ledger_entry
+
+    @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/credit_ledger_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.credit_ledger_entry import CreditLedgerEntry
+
+
+T = TypeVar("T", bound="CreditLedgerResponse")
+
+
+@_attrs_define
+class CreditLedgerResponse:
+    """
+    Attributes:
+        entries (list[CreditLedgerEntry]):
+        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.
+    """
+
+    entries: list[CreditLedgerEntry]
+    next_cursor: None | str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        entries = []
+        for entries_item_data in self.entries:
+            entries_item = entries_item_data.to_dict()
+            entries.append(entries_item)
+
+        next_cursor: None | str
+        next_cursor = self.next_cursor
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "entries": entries,
+                "next_cursor": next_cursor,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.credit_ledger_entry import CreditLedgerEntry  # noqa: PLC0415
+
+        d = dict(src_dict)
+        entries = []
+        _entries = d.pop("entries")
+        for entries_item_data in _entries:
+            entries_item = CreditLedgerEntry.from_dict(entries_item_data)
+
+            entries.append(entries_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"))
+
+        credit_ledger_response = cls(
+            entries=entries,
+            next_cursor=next_cursor,
+        )
+
+        credit_ledger_response.additional_properties = d
+        return credit_ledger_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