hushscript 1.0.0__py3-none-any.whl

hushscript/generated/models/transactions_response.py

@@ -0,0 +1,98 @@
+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.transaction import Transaction
+
+
+T = TypeVar("T", bound="TransactionsResponse")
+
+
+@_attrs_define
+class TransactionsResponse:
+    """
+    Attributes:
+        transactions (list[Transaction]):
+        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.
+        account_reference (str):
+    """
+
+    transactions: list[Transaction]
+    next_cursor: None | str
+    account_reference: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        transactions = []
+        for transactions_item_data in self.transactions:
+            transactions_item = transactions_item_data.to_dict()
+            transactions.append(transactions_item)
+
+        next_cursor: None | str
+        next_cursor = self.next_cursor
+
+        account_reference = self.account_reference
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "transactions": transactions,
+                "next_cursor": next_cursor,
+                "account_reference": account_reference,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.transaction import Transaction  # noqa: PLC0415
+
+        d = dict(src_dict)
+        transactions = []
+        _transactions = d.pop("transactions")
+        for transactions_item_data in _transactions:
+            transactions_item = Transaction.from_dict(transactions_item_data)
+
+            transactions.append(transactions_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"))
+
+        account_reference = d.pop("account_reference")
+
+        transactions_response = cls(
+            transactions=transactions,
+            next_cursor=next_cursor,
+            account_reference=account_reference,
+        )
+
+        transactions_response.additional_properties = d
+        return transactions_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/transcript_detail.py

@@ -0,0 +1,194 @@
+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.transcript_detail_speaker_names import TranscriptDetailSpeakerNames
+    from ..models.transcript_envelope import TranscriptEnvelope
+
+
+T = TypeVar("T", bound="TranscriptDetail")
+
+
+@_attrs_define
+class TranscriptDetail:
+    """
+    Attributes:
+        id (str):
+        title (str):
+        language_detected (None | str):
+        duration_seconds (int):
+        speaker_names (TranscriptDetailSpeakerNames): Provider speaker label mapped to a display name, for every speaker
+            the caller has renamed.
+        tags (list[str]):
+        created_at (int):
+        updated_at (int):
+        auto_delete_at (int | None): When this transcript is scheduled to be purged, or null to keep it indefinitely.
+        edited (bool): Whether the original body has been edited since transcription.
+        matter_code (None | str): The workspace matter this transcript is filed under, or null. Set at upload time and
+            editable afterwards; always null for a transcript that was never funded by a workspace.
+        client_code (None | str): The workspace client this transcript is filed under, or null. Set at upload time and
+            editable afterwards; always null for a transcript that was never funded by a workspace.
+        body (TranscriptEnvelope): The transcript's full structured body.
+    """
+
+    id: str
+    title: str
+    language_detected: None | str
+    duration_seconds: int
+    speaker_names: TranscriptDetailSpeakerNames
+    tags: list[str]
+    created_at: int
+    updated_at: int
+    auto_delete_at: int | None
+    edited: bool
+    matter_code: None | str
+    client_code: None | str
+    body: TranscriptEnvelope
+    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
+
+        speaker_names = self.speaker_names.to_dict()
+
+        tags = self.tags
+
+        created_at = self.created_at
+
+        updated_at = self.updated_at
+
+        auto_delete_at: int | None
+        auto_delete_at = self.auto_delete_at
+
+        edited = self.edited
+
+        matter_code: None | str
+        matter_code = self.matter_code
+
+        client_code: None | str
+        client_code = self.client_code
+
+        body = self.body.to_dict()
+
+        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,
+                "speaker_names": speaker_names,
+                "tags": tags,
+                "created_at": created_at,
+                "updated_at": updated_at,
+                "auto_delete_at": auto_delete_at,
+                "edited": edited,
+                "matter_code": matter_code,
+                "client_code": client_code,
+                "body": body,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.transcript_detail_speaker_names import (
+            TranscriptDetailSpeakerNames,  # noqa: PLC0415
+        )
+        from ..models.transcript_envelope import TranscriptEnvelope  # 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")
+
+        speaker_names = TranscriptDetailSpeakerNames.from_dict(d.pop("speaker_names"))
+
+        tags = cast(list[str], d.pop("tags"))
+
+        created_at = d.pop("created_at")
+
+        updated_at = d.pop("updated_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"))
+
+        edited = d.pop("edited")
+
+        def _parse_matter_code(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        matter_code = _parse_matter_code(d.pop("matter_code"))
+
+        def _parse_client_code(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        client_code = _parse_client_code(d.pop("client_code"))
+
+        body = TranscriptEnvelope.from_dict(d.pop("body"))
+
+        transcript_detail = cls(
+            id=id,
+            title=title,
+            language_detected=language_detected,
+            duration_seconds=duration_seconds,
+            speaker_names=speaker_names,
+            tags=tags,
+            created_at=created_at,
+            updated_at=updated_at,
+            auto_delete_at=auto_delete_at,
+            edited=edited,
+            matter_code=matter_code,
+            client_code=client_code,
+            body=body,
+        )
+
+        transcript_detail.additional_properties = d
+        return transcript_detail
+
+    @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_detail_speaker_names.py

@@ -0,0 +1,47 @@
+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="TranscriptDetailSpeakerNames")
+
+
+@_attrs_define
+class TranscriptDetailSpeakerNames:
+    """Provider speaker label mapped to a display name, for every speaker the caller has renamed."""
+
+    additional_properties: dict[str, str] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        transcript_detail_speaker_names = cls()
+
+        transcript_detail_speaker_names.additional_properties = d
+        return transcript_detail_speaker_names
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> 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_envelope.py

@@ -0,0 +1,89 @@
+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.transcript_envelope_translations import TranscriptEnvelopeTranslations
+    from ..models.transcript_language import TranscriptLanguage
+
+
+T = TypeVar("T", bound="TranscriptEnvelope")
+
+
+@_attrs_define
+class TranscriptEnvelope:
+    """The transcript's full structured body.
+
+    Attributes:
+        version (int):
+        original (TranscriptLanguage):
+        translations (TranscriptEnvelopeTranslations): Keyed by target locale, plus the reserved key cleaned for the AI-
+            rewritten cleaned body when one exists.
+    """
+
+    version: int
+    original: TranscriptLanguage
+    translations: TranscriptEnvelopeTranslations
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        version = self.version
+
+        original = self.original.to_dict()
+
+        translations = self.translations.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "version": version,
+                "original": original,
+                "translations": translations,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.transcript_envelope_translations import (
+            TranscriptEnvelopeTranslations,  # noqa: PLC0415
+        )
+        from ..models.transcript_language import TranscriptLanguage  # noqa: PLC0415
+
+        d = dict(src_dict)
+        version = d.pop("version")
+
+        original = TranscriptLanguage.from_dict(d.pop("original"))
+
+        translations = TranscriptEnvelopeTranslations.from_dict(d.pop("translations"))
+
+        transcript_envelope = cls(
+            version=version,
+            original=original,
+            translations=translations,
+        )
+
+        transcript_envelope.additional_properties = d
+        return transcript_envelope
+
+    @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_envelope_translations.py

@@ -0,0 +1,62 @@
+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.transcript_language import TranscriptLanguage
+
+
+T = TypeVar("T", bound="TranscriptEnvelopeTranslations")
+
+
+@_attrs_define
+class TranscriptEnvelopeTranslations:
+    """Keyed by target locale, plus the reserved key cleaned for the AI-rewritten cleaned body when one exists."""
+
+    additional_properties: dict[str, TranscriptLanguage] = _attrs_field(
+        init=False, factory=dict
+    )
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.transcript_language import TranscriptLanguage  # noqa: PLC0415
+
+        d = dict(src_dict)
+        transcript_envelope_translations = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = TranscriptLanguage.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        transcript_envelope_translations.additional_properties = additional_properties
+        return transcript_envelope_translations
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> TranscriptLanguage:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: TranscriptLanguage) -> 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_language.py

@@ -0,0 +1,75 @@
+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.utterance import Utterance
+
+
+T = TypeVar("T", bound="TranscriptLanguage")
+
+
+@_attrs_define
+class TranscriptLanguage:
+    """
+    Attributes:
+        utterances (list[Utterance]):
+    """
+
+    utterances: list[Utterance]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        utterances = []
+        for utterances_item_data in self.utterances:
+            utterances_item = utterances_item_data.to_dict()
+            utterances.append(utterances_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "utterances": utterances,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.utterance import Utterance  # noqa: PLC0415
+
+        d = dict(src_dict)
+        utterances = []
+        _utterances = d.pop("utterances")
+        for utterances_item_data in _utterances:
+            utterances_item = Utterance.from_dict(utterances_item_data)
+
+            utterances.append(utterances_item)
+
+        transcript_language = cls(
+            utterances=utterances,
+        )
+
+        transcript_language.additional_properties = d
+        return transcript_language
+
+    @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.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.transcript_list_row import TranscriptListRow
+
+
+T = TypeVar("T", bound="TranscriptList")
+
+
+@_attrs_define
+class TranscriptList:
+    """
+    Attributes:
+        transcripts (list[TranscriptListRow]):
+        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.
+    """
+
+    transcripts: list[TranscriptListRow]
+    next_cursor: None | str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        transcripts = []
+        for transcripts_item_data in self.transcripts:
+            transcripts_item = transcripts_item_data.to_dict()
+            transcripts.append(transcripts_item)
+
+        next_cursor: None | str
+        next_cursor = self.next_cursor
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "transcripts": transcripts,
+                "next_cursor": next_cursor,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.transcript_list_row import TranscriptListRow  # noqa: PLC0415
+
+        d = dict(src_dict)
+        transcripts = []
+        _transcripts = d.pop("transcripts")
+        for transcripts_item_data in _transcripts:
+            transcripts_item = TranscriptListRow.from_dict(transcripts_item_data)
+
+            transcripts.append(transcripts_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"))
+
+        transcript_list = cls(
+            transcripts=transcripts,
+            next_cursor=next_cursor,
+        )
+
+        transcript_list.additional_properties = d
+        return transcript_list
+
+    @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