hushscript 1.0.0__py3-none-any.whl

hushscript/generated/models/upload_limits.py

@@ -0,0 +1,86 @@
+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="UploadLimits")
+
+
+@_attrs_define
+class UploadLimits:
+    """The caller's current upload admission limits, shared by every response that carries them.
+
+    Attributes:
+        max_daily_seconds (int): The account's daily transcription-minutes cap, in seconds.
+        max_active_jobs (int): The maximum number of concurrent pipeline jobs this account may have in flight.
+        active_jobs (int): How many pipeline jobs are currently in flight.
+        used_today_seconds (int): Billable seconds already used today, in the account's own rolling day.
+    """
+
+    max_daily_seconds: int
+    max_active_jobs: int
+    active_jobs: int
+    used_today_seconds: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        max_daily_seconds = self.max_daily_seconds
+
+        max_active_jobs = self.max_active_jobs
+
+        active_jobs = self.active_jobs
+
+        used_today_seconds = self.used_today_seconds
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "max_daily_seconds": max_daily_seconds,
+                "max_active_jobs": max_active_jobs,
+                "active_jobs": active_jobs,
+                "used_today_seconds": used_today_seconds,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        max_daily_seconds = d.pop("max_daily_seconds")
+
+        max_active_jobs = d.pop("max_active_jobs")
+
+        active_jobs = d.pop("active_jobs")
+
+        used_today_seconds = d.pop("used_today_seconds")
+
+        upload_limits = cls(
+            max_daily_seconds=max_daily_seconds,
+            max_active_jobs=max_active_jobs,
+            active_jobs=active_jobs,
+            used_today_seconds=used_today_seconds,
+        )
+
+        upload_limits.additional_properties = d
+        return upload_limits
+
+    @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_part_response_200.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="UploadPartResponse200")
+
+
+@_attrs_define
+class UploadPartResponse200:
+    """
+    Attributes:
+        ok (bool):
+        part (int):
+    """
+
+    ok: bool
+    part: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        ok = self.ok
+
+        part = self.part
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "ok": ok,
+                "part": part,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        part = d.pop("part")
+
+        upload_part_response_200 = cls(
+            ok=ok,
+            part=part,
+        )
+
+        upload_part_response_200.additional_properties = d
+        return upload_part_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/utterance.py

@@ -0,0 +1,85 @@
+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="Utterance")
+
+
+@_attrs_define
+class Utterance:
+    """
+    Attributes:
+        speaker (str):
+        start_ms (int):
+        end_ms (int):
+        text (str):
+    """
+
+    speaker: str
+    start_ms: int
+    end_ms: int
+    text: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        speaker = self.speaker
+
+        start_ms = self.start_ms
+
+        end_ms = self.end_ms
+
+        text = self.text
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "speaker": speaker,
+                "start_ms": start_ms,
+                "end_ms": end_ms,
+                "text": text,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        speaker = d.pop("speaker")
+
+        start_ms = d.pop("start_ms")
+
+        end_ms = d.pop("end_ms")
+
+        text = d.pop("text")
+
+        utterance = cls(
+            speaker=speaker,
+            start_ms=start_ms,
+            end_ms=end_ms,
+            text=text,
+        )
+
+        utterance.additional_properties = d
+        return utterance
+
+    @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/scopes.py

@@ -0,0 +1,42 @@
+# Generated by scripts/generate.py from openapi.json and the conformance hints.json. Do not edit.
+
+from typing import Final
+
+OPERATION_SCOPES: Final[dict[str, str]] = {
+    "DELETE /v1/org/transcripts/{id}/hold": "org:write",
+    "GET /v1/account": "account:read",
+    "GET /v1/billing/cards": "billing",
+    "GET /v1/billing/holds": "account:read",
+    "GET /v1/billing/ledger": "account:read",
+    "GET /v1/billing/packs": "billing",
+    "GET /v1/billing/transactions": "account:read",
+    "GET /v1/jobs": "transcribe",
+    "GET /v1/jobs/{id}": "transcribe",
+    "GET /v1/org": "org:read",
+    "GET /v1/org/audit": "org:read",
+    "GET /v1/org/audit.csv": "org:read",
+    "GET /v1/org/invoices": "org:read",
+    "GET /v1/org/ledger": "org:read",
+    "GET /v1/org/ledger.csv": "org:read",
+    "GET /v1/org/matters": "org:read",
+    "GET /v1/org/members": "org:read",
+    "GET /v1/org/transcripts": "org:read",
+    "GET /v1/org/usage": "org:read",
+    "GET /v1/org/usage.csv": "org:read",
+    "GET /v1/transcription-context": "context",
+    "GET /v1/transcripts": "transcripts:read",
+    "GET /v1/transcripts/deleted": "transcripts:read",
+    "GET /v1/transcripts/{id}": "transcripts:read",
+    "GET /v1/uploads/{job}/part-urls": "transcribe",
+    "PATCH /v1/org/members/{user_id}": "org:write",
+    "POST /v1/agent/credentials/rotate": "pat:rotate",
+    "POST /v1/billing/cards/default": "billing",
+    "POST /v1/billing/purchase": "billing",
+    "POST /v1/billing/setup-session": "billing",
+    "POST /v1/org/custody": "org:write",
+    "POST /v1/org/transcripts/{id}/hold": "org:write",
+    "POST /v1/uploads": "transcribe",
+    "POST /v1/uploads/{job}/complete": "transcribe",
+    "POST /v1/uploads/{job}/heartbeat": "transcribe",
+    "PUT /v1/uploads/{job}/parts/{n}": "transcribe",
+}

hushscript/generated/types.py

@@ -0,0 +1,54 @@
+"""Contains some shared types for properties"""
+
+from collections.abc import Mapping, MutableMapping
+from http import HTTPStatus
+from typing import IO, BinaryIO, Generic, Literal, TypeVar
+
+from attrs import define
+
+
+class Unset:
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+UNSET: Unset = Unset()
+
+# The types that `httpx.Client(files=)` can accept, copied from that library.
+FileContent = IO[bytes] | bytes | str
+FileTypes = (
+    # (filename, file (or bytes), content_type)
+    tuple[str | None, FileContent, str | None]
+    # (filename, file (or bytes), content_type, headers)
+    | tuple[str | None, FileContent, str | None, Mapping[str, str]]
+)
+RequestFiles = list[tuple[str, FileTypes]]
+
+
+@define
+class File:
+    """Contains information for file uploads"""
+
+    payload: BinaryIO
+    file_name: str | None = None
+    mime_type: str | None = None
+
+    def to_tuple(self) -> FileTypes:
+        """Return a tuple representation that httpx will accept for multipart/form-data"""
+        return self.file_name, self.payload, self.mime_type
+
+
+T = TypeVar("T")
+
+
+@define
+class Response(Generic[T]):
+    """A response from an endpoint"""
+
+    status_code: HTTPStatus
+    content: bytes
+    headers: MutableMapping[str, str]
+    parsed: T | None
+
+
+__all__ = ["UNSET", "File", "FileTypes", "RequestFiles", "Response", "Unset"]

hushscript/money.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final
+
+from ._json import ExtraFields
+
+
+@dataclass(frozen=True, slots=True)
+class Money(ExtraFields):
+    """A price as the API states it, with a display string in the `en` locale.
+
+    The amount digits and the grouping (minor-unit digits from Stripe's table, thousands grouped
+    with commas) are the same in every Hushscript SDK. The rest of `formatted` is this SDK's own: it
+    writes `$`, `€`, `£` or `¥` for USD, EUR, GBP and JPY, and for every other known currency the
+    code and a no-break space before the number (`KRW 1,234`), where the TypeScript SDK takes its
+    symbols from Intl and may print another. Compare `amount` and `currency`, never `formatted`,
+    across SDKs.
+    """
+
+    amount: int
+    """In the currency's minor units, from the API."""
+    currency: str
+    """The ISO 4217 code as the API sends it."""
+    formatted: str
+    """`amount` divided by Stripe's minor-unit digits for the currency, for example `$5.99`."""
+
+
+# Stripe's minor-unit digits, which the API's amounts use (spec 6.5). They come from this table and
+# never from locale data: ICU disagrees for IDR, HUF, ISK and others.
+_ZERO_DIGITS: Final = frozenset(
+    "BIF CLP DJF GNF JPY KMF KRW MGA PYG RWF UGX VND VUV XAF XOF XPF".split()  # noqa: SIM905
+)
+_THREE_DIGITS: Final = frozenset("BHD JOD KWD OMR TND".split())  # noqa: SIM905
+# The ISO 4217 codes printed with the code in front; any other string is shown plainly, as
+# "5.99 ZZZ", and never fails.
+_KNOWN: Final = frozenset(
+    """
+    AED AFN ALL AMD ANG AOA ARS AUD AWG AZN BAM BBD BDT BGN BHD BIF BMD BND BOB BRL BSD
+    BTN BWP BYN BZD CAD CDF CHF CLP CNY COP CRC CUP CVE CZK DJF DKK DOP DZD EGP ERN ETB
+    EUR FJD FKP GBP GEL GHS GIP GMD GNF GTQ GYD HKD HNL HTG HUF IDR ILS INR IQD IRR ISK
+    JMD JOD JPY KES KGS KHR KMF KPW KRW KWD KYD KZT LAK LBP LKR LRD LSL LYD MAD MDL MGA
+    MKD MMK MNT MOP MRU MUR MVR MWK MXN MYR MZN NAD NGN NIO NOK NPR NZD OMR PAB PEN PGK
+    PHP PKR PLN PYG QAR RON RSD RUB RWF SAR SBD SCR SDG SEK SGD SHP SLE SOS SRD SSP STN
+    SVC SYP SZL THB TJS TMT TND TOP TRY TTD TWD TZS UAH UGX USD UYU UZS VES VND VUV WST
+    XAF XCD XOF XPF YER ZAR ZMW ZWG
+    """.split()  # noqa: SIM905
+)
+_SYMBOLS: Final = {"USD": "$", "EUR": "€", "GBP": "£", "JPY": "¥"}
+_NO_BREAK_SPACE: Final = chr(0xA0)
+_ZERO_DIGIT_COUNT: Final = 0
+_THREE_DIGIT_COUNT: Final = 3
+_DEFAULT_DIGITS: Final = 2
+
+
+def minor_unit_digits(code: str) -> int:
+    if code in _ZERO_DIGITS:
+        return _ZERO_DIGIT_COUNT
+    return _THREE_DIGIT_COUNT if code in _THREE_DIGITS else _DEFAULT_DIGITS
+
+
+def to_money(amount: int, currency: str) -> Money:
+    """The `Money` of an API amount and currency; an unknown currency is shown as the plain amount
+    and the upper-cased code with 2 digits, and never raises."""
+    code = currency.upper()
+    digits = minor_unit_digits(code)
+    magnitude = abs(amount)
+    whole, fraction = divmod(magnitude, 10**digits)
+    known = code in _KNOWN
+    number = f"{whole:,}" if known else str(whole)
+    if digits:
+        number += f".{fraction:0{digits}d}"
+    sign = "-" if amount < 0 else ""
+    if not known:
+        return Money(amount, currency, f"{sign}{number} {code}")
+    symbol = _SYMBOLS.get(code)
+    if symbol is not None:
+        return Money(amount, currency, f"{sign}{symbol}{number}")
+    return Money(amount, currency, f"{sign}{code}{_NO_BREAK_SPACE}{number}")

hushscript/paginate.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Generic, TypeVar, cast
+
+from ._errors import HushscriptError
+from ._json import ExtraFields
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Awaitable, Callable, Iterator
+
+T = TypeVar("T")
+
+
+@dataclass(frozen=True, slots=True)
+class Page(ExtraFields, Generic[T]):
+    """One page of a list. `next_cursor` is opaque and None on the last page."""
+
+    items: list[T]
+    next_cursor: str | None
+
+    __hash__ = None  # type: ignore[assignment]  # holds a list, so it is unhashable by design
+
+
+if sys.version_info < (3, 11):
+    _page_setattr = cast("Callable[[object, str, object], None]", vars(Page)["__setattr__"])
+
+    def _page_setattr_compat(self: object, name: str, value: object) -> None:
+        # Python 3.10's generic constructor only ignores AttributeError for type metadata.
+        if name == "__orig_class__":
+            raise AttributeError(name)
+        _page_setattr(self, name, value)
+
+    Page.__setattr__ = _page_setattr_compat  # type: ignore[method-assign]
+
+
+def pagination_loop() -> HushscriptError:
+    return HushscriptError(
+        "The API returned the same page cursor it was sent; stopping instead of repeating it.",
+        code="pagination_loop",
+    )
+
+
+def check_cursor_advanced(sent: str | None, page: Page[T]) -> None:
+    """R89: a page that hands back the cursor it was asked with would repeat forever."""
+    if page.next_cursor and page.next_cursor == sent:
+        raise pagination_loop()
+
+
+def paginate(fetch: Callable[[str | None], Page[T]]) -> Iterator[T]:
+    """Walks a cursor-paged list one page at a time, yielding every item in order. The walk is lazy:
+    closing the iterator (or breaking out of a loop over it) sends no further request. A page that
+    hands back the cursor it was asked with would repeat forever, so it raises `pagination_loop`
+    once its items have been yielded."""
+    cursor: str | None = None
+    while True:
+        sent = cursor
+        page = fetch(sent)
+        yield from page.items
+        check_cursor_advanced(sent, page)
+        cursor = page.next_cursor or None
+        if cursor is None:
+            return
+
+
+async def apaginate(fetch: Callable[[str | None], Awaitable[Page[T]]]) -> AsyncIterator[T]:
+    """`paginate` on the event loop; a cancellation between pages ends the walk there."""
+    cursor: str | None = None
+    while True:
+        sent = cursor
+        page = await fetch(sent)
+        for item in page.items:
+            yield item
+        check_cursor_advanced(sent, page)
+        cursor = page.next_cursor or None
+        if cursor is None:
+            return

hushscript/resources/__init__.py

@@ -0,0 +1 @@
+

hushscript/resources/_params.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from urllib.parse import quote
+
+from hushscript.transcribe.preflight import invalid_option
+
+
+def check_page_size(page_size: object) -> None:
+    if page_size is None:
+        return
+    if isinstance(page_size, bool) or not isinstance(page_size, int) or page_size < 1:
+        raise invalid_option("page_size must be a whole number of 1 or more.")
+
+
+def path_id(resource_id: object) -> str:
+    """An id as one percent-encoded path segment. An empty or non-string id, `.` and `..` (which a
+    client or proxy would resolve to another route) and text that cannot be encoded as UTF-8 (a
+    lone surrogate) are `invalid_option`, before any request."""
+    if not isinstance(resource_id, str) or resource_id in {"", ".", ".."}:
+        raise invalid_option("An id is a non-empty string other than . and ..")
+    try:
+        return quote(resource_id, safe="")
+    except UnicodeEncodeError:
+        raise invalid_option("An id must be text that encodes as UTF-8.") from None
+
+
+def list_params(cursor: str | None, page_size: int | None) -> dict[str, str | int]:
+    params: dict[str, str | int] = {}
+    if page_size is not None:
+        params["limit"] = page_size
+    if cursor is not None:
+        params["cursor"] = cursor
+    return params

hushscript/resources/account.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from hushscript._json import ExtraFields, as_dict, extra_fields
+from hushscript._shape import as_flag, as_text, as_whole, check_shape, maybe_whole, to_datetime
+from hushscript._shapes import ACCOUNT, BALANCE
+
+if TYPE_CHECKING:
+    from datetime import datetime
+
+
+def _expiry(fields: dict[str, object]) -> datetime | None:
+    expires = fields.get("credits_expire_at")
+    return None if expires is None else to_datetime(expires)
+
+
+def minutes_of(seconds: int) -> int:
+    """`seconds / 60` rounded toward zero, exact for any size of int."""
+    return seconds // 60 if seconds >= 0 else -(-seconds // 60)
+
+
+@dataclass(frozen=True, slots=True)
+class Balance(ExtraFields):
+    seconds: int
+    """Spendable now, already net of holds (not "balance minus held"); may be negative
+    (clawback debt)."""
+    minutes: int
+    """`seconds / 60`, rounded toward zero."""
+    held_seconds: int
+    """Committed to in-flight jobs, and already deducted from `seconds`."""
+    expires_at: datetime | None
+    purchases_remaining: int | None
+    """Agent accounts only, else None."""
+
+    @classmethod
+    def from_account(cls, body: object) -> Balance:
+        check_shape(body, BALANCE, "account response")
+        fields = as_dict(body) or {}
+        seconds = as_whole(fields["balance_seconds"])
+        return cls(
+            _extra=extra_fields(
+                fields,
+                "balance_seconds",
+                "held_seconds",
+                "credits_expire_at",
+                "purchases_remaining_in_window",
+            ),
+            seconds=seconds,
+            minutes=minutes_of(seconds),
+            held_seconds=as_whole(fields["held_seconds"]),
+            expires_at=_expiry(fields),
+            purchases_remaining=maybe_whole(fields.get("purchases_remaining_in_window")),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class UploadLimits(ExtraFields):
+    """The caller's upload admission limits. Unknown API keys remain available in `extra`."""
+
+    max_daily_seconds: int
+    """The daily transcription cap, in seconds."""
+    max_active_jobs: int
+    """The most pipeline jobs in flight at once."""
+    active_jobs: int
+    """Pipeline jobs in flight now."""
+    used_today_seconds: int
+    """Billable seconds used today."""
+
+
+@dataclass(frozen=True, slots=True)
+class Account(ExtraFields):
+    balance_seconds: int
+    """Net of holds and clawback debt; may be negative."""
+    held_seconds: int
+    """Committed to in-flight jobs, and already deducted from `balance_seconds`."""
+    credits_expire_at: datetime | None
+    card_on_file: bool
+    data_region: str
+    """For example `us`, `eu`, `apac` or `oc`."""
+    limits: UploadLimits
+    purchases_remaining_in_window: int | None
+    """Agent accounts only, else None."""
+
+    @classmethod
+    def from_body(cls, body: object) -> Account:
+        check_shape(body, ACCOUNT, "account response")
+        fields = as_dict(body) or {}
+        limits = as_dict(fields["limits"]) or {}
+        return cls(
+            _extra=extra_fields(
+                fields,
+                "balance_seconds",
+                "held_seconds",
+                "credits_expire_at",
+                "card_on_file",
+                "data_region",
+                "limits",
+                "purchases_remaining_in_window",
+            ),
+            balance_seconds=as_whole(fields["balance_seconds"]),
+            held_seconds=as_whole(fields["held_seconds"]),
+            credits_expire_at=_expiry(fields),
+            card_on_file=as_flag(fields["card_on_file"]),
+            data_region=as_text(fields["data_region"]),
+            limits=UploadLimits(
+                _extra=extra_fields(
+                    limits,
+                    "max_daily_seconds",
+                    "max_active_jobs",
+                    "active_jobs",
+                    "used_today_seconds",
+                ),
+                max_daily_seconds=as_whole(limits["max_daily_seconds"]),
+                max_active_jobs=as_whole(limits["max_active_jobs"]),
+                active_jobs=as_whole(limits["active_jobs"]),
+                used_today_seconds=as_whole(limits["used_today_seconds"]),
+            ),
+            purchases_remaining_in_window=maybe_whole(fields.get("purchases_remaining_in_window")),
+        )