together 1.5.35__py3-none-any.whl → 2.0.0a6__py3-none-any.whl

together/resources/audio/transcriptions.py

@@ -1,296 +1,282 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
 from __future__ import annotations
 
-from pathlib import Path
-from typing import Any, BinaryIO, Dict, Optional, Tuple, Union
-
-from together.abstract import api_requestor
-from together.types import (
-    AudioTimestampGranularities,
-    AudioTranscriptionResponse,
-    AudioTranscriptionResponseFormat,
-    AudioTranscriptionVerboseResponse,
-    TogetherClient,
-    TogetherRequest,
+from typing import Any, List, Union, Mapping, cast
+from typing_extensions import Literal
+
+import httpx
+
+from ..._types import Body, Omit, Query, Headers, NotGiven, FileTypes, omit, not_given
+from ..._utils import extract_files, maybe_transform, deepcopy_minimal, async_maybe_transform
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
 )
+from ...types.audio import transcription_create_params
+from ..._base_client import make_request_options
+from ...types.audio.transcription_create_response import TranscriptionCreateResponse
 
+__all__ = ["TranscriptionsResource", "AsyncTranscriptionsResource"]
 
-class Transcriptions:
-    def __init__(self, client: TogetherClient) -> None:
-        self._client = client
+
+class TranscriptionsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> TranscriptionsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/togethercomputer/together-py#accessing-raw-response-data-eg-headers
+        """
+        return TranscriptionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> TranscriptionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/togethercomputer/together-py#with_streaming_response
+        """
+        return TranscriptionsResourceWithStreamingResponse(self)
 
     def create(
         self,
         *,
-        file: Union[str, BinaryIO, Path],
-        model: str = "openai/whisper-large-v3",
-        language: Optional[str] = None,
-        prompt: Optional[str] = None,
-        response_format: Union[str, AudioTranscriptionResponseFormat] = "json",
-        temperature: float = 0.0,
-        timestamp_granularities: Optional[
-            Union[str, AudioTimestampGranularities]
-        ] = None,
-        diarize: bool = False,
-        **kwargs: Any,
-    ) -> Union[AudioTranscriptionResponse, AudioTranscriptionVerboseResponse]:
+        file: FileTypes,
+        diarize: bool | Omit = omit,
+        language: str | Omit = omit,
+        model: Literal["openai/whisper-large-v3"] | Omit = omit,
+        prompt: str | Omit = omit,
+        response_format: Literal["json", "verbose_json"] | Omit = omit,
+        temperature: float | Omit = omit,
+        timestamp_granularities: Union[Literal["segment", "word"], List[Literal["segment", "word"]]] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> TranscriptionCreateResponse:
         """
-        Transcribes audio into the input language.
+        Transcribes audio into text
 
         Args:
-            file: The audio file object (not file name) to transcribe, in one of these formats:
-                flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
-                Can be a file path (str/Path), file object (BinaryIO), or URL (str).
-            model: ID of the model to use. Defaults to "openai/whisper-large-v3".
-            language: The language of the input audio. Supplying the input language in
-                ISO-639-1 format will improve accuracy and latency.
-            prompt: An optional text to guide the model's style or continue a previous
-                audio segment. The prompt should match the audio language.
-            response_format: The format of the transcript output, in one of these options:
-                json, verbose_json.
-            temperature: The sampling temperature, between 0 and 1. Higher values like 0.8
-                will make the output more random, while lower values like 0.2 will make it
-                more focused and deterministic.
-            timestamp_granularities: The timestamp granularities to populate for this
-                transcription. response_format must be set verbose_json to use timestamp
-                granularities. Either or both of these options are supported: word, or segment.
-            diarize: Whether to enable speaker diarization. When enabled, you will get the speaker id for each word in the transcription.
-                In the response, in the words array, you will get the speaker id for each word.
-                In addition, we also return the speaker_segments array which contains the speaker id for each speaker segment along with the start and end time of the segment along with all the words in the segment.
-                You can use the speaker_id to group the words by speaker.
-                You can use the speaker_segments to get the start and end time of each speaker segment.
-        Returns:
-            The transcribed text in the requested format.
-        """
+          file: Audio file to transcribe
 
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
+          diarize: Whether to enable speaker diarization. When enabled, you will get the speaker id
+              for each word in the transcription. In the response, in the words array, you
+              will get the speaker id for each word. In addition, we also return the
+              speaker_segments array which contains the speaker id for each speaker segment
+              along with the start and end time of the segment along with all the words in the
+              segment.
+
+              For eg - ... "speaker_segments": [ "speaker_id": "SPEAKER_00", "start": 0,
+              "end": 30.02, "words": [ { "id": 0, "word": "Tijana", "start": 0, "end": 11.475,
+              "speaker_id": "SPEAKER_00" }, ...
+
+          language: Optional ISO 639-1 language code. If `auto` is provided, language is
+              auto-detected.
+
+          model: Model to use for transcription
+
+          prompt: Optional text to bias decoding.
 
-        # Handle file input - could be a path, URL, or file object
-        files_data: Dict[str, Union[Tuple[None, str], BinaryIO]] = {}
-        params_data = {}
-
-        if isinstance(file, (str, Path)):
-            if isinstance(file, str) and file.startswith(("http://", "https://")):
-                # URL string - send as multipart field
-                files_data["file"] = (None, file)
-            else:
-                # Local file path
-                file_path = Path(file)
-                files_data["file"] = open(file_path, "rb")
-        else:
-            # File object
-            files_data["file"] = file
-
-        # Build request parameters
-        params_data.update(
+          response_format: The format of the response
+
+          temperature: Sampling temperature between 0.0 and 1.0
+
+          timestamp_granularities: Controls level of timestamp detail in verbose_json. Only used when
+              response_format is verbose_json. Can be a single granularity or an array to get
+              multiple levels.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        body = deepcopy_minimal(
             {
+                "file": file,
+                "diarize": diarize,
+                "language": language,
                 "model": model,
-                "response_format": (
-                    response_format.value
-                    if hasattr(response_format, "value")
-                    else response_format
-                ),
+                "prompt": prompt,
+                "response_format": response_format,
                 "temperature": temperature,
+                "timestamp_granularities": timestamp_granularities,
             }
         )
-
-        if language is not None:
-            params_data["language"] = language
-
-        if prompt is not None:
-            params_data["prompt"] = prompt
-
-        if timestamp_granularities is not None:
-            params_data["timestamp_granularities"] = (
-                timestamp_granularities.value
-                if hasattr(timestamp_granularities, "value")
-                else timestamp_granularities
-            )
-
-        if diarize:
-            params_data["diarize"] = diarize
-
-        # Add any additional kwargs
-        # Convert boolean values to lowercase strings for proper form encoding
-        for key, value in kwargs.items():
-            if isinstance(value, bool):
-                params_data[key] = str(value).lower()
-            else:
-                params_data[key] = value
-
-        try:
-            response, _, _ = requestor.request(
-                options=TogetherRequest(
-                    method="POST",
-                    url="audio/transcriptions",
-                    params=params_data,
-                    files=files_data,
+        files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
+        return cast(
+            TranscriptionCreateResponse,
+            self._post(
+                "/audio/transcriptions",
+                body=maybe_transform(body, transcription_create_params.TranscriptionCreateParams),
+                files=files,
+                options=make_request_options(
+                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
                 ),
-            )
-        finally:
-            # Close file if we opened it
-            if files_data and "file" in files_data:
-                try:
-                    # Only close if it's a file object (not a tuple for URL)
-                    file_obj = files_data["file"]
-                    if hasattr(file_obj, "close") and not isinstance(file_obj, tuple):
-                        file_obj.close()
-                except:
-                    pass
-
-        # Parse response based on format
-        if (
-            response_format == "verbose_json"
-            or response_format == AudioTranscriptionResponseFormat.VERBOSE_JSON
-            or diarize
-        ):
-            # Create response with model validation that preserves extra fields
-            return AudioTranscriptionVerboseResponse.model_validate(response.data)
-        else:
-            return AudioTranscriptionResponse(**response.data)
-
-
-class AsyncTranscriptions:
-    def __init__(self, client: TogetherClient) -> None:
-        self._client = client
+                cast_to=cast(
+                    Any, TranscriptionCreateResponse
+                ),  # Union types cannot be passed in as arguments in the type system
+            ),
+        )
+
+
+class AsyncTranscriptionsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncTranscriptionsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/togethercomputer/together-py#accessing-raw-response-data-eg-headers
+        """
+        return AsyncTranscriptionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncTranscriptionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/togethercomputer/together-py#with_streaming_response
+        """
+        return AsyncTranscriptionsResourceWithStreamingResponse(self)
 
     async def create(
         self,
         *,
-        file: Union[str, BinaryIO, Path],
-        model: str = "openai/whisper-large-v3",
-        language: Optional[str] = None,
-        prompt: Optional[str] = None,
-        response_format: Union[str, AudioTranscriptionResponseFormat] = "json",
-        temperature: float = 0.0,
-        timestamp_granularities: Optional[
-            Union[str, AudioTimestampGranularities]
-        ] = None,
-        diarize: bool = False,
-        **kwargs: Any,
-    ) -> Union[AudioTranscriptionResponse, AudioTranscriptionVerboseResponse]:
+        file: FileTypes,
+        diarize: bool | Omit = omit,
+        language: str | Omit = omit,
+        model: Literal["openai/whisper-large-v3"] | Omit = omit,
+        prompt: str | Omit = omit,
+        response_format: Literal["json", "verbose_json"] | Omit = omit,
+        temperature: float | Omit = omit,
+        timestamp_granularities: Union[Literal["segment", "word"], List[Literal["segment", "word"]]] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> TranscriptionCreateResponse:
         """
-        Async version of transcribe audio into the input language.
+        Transcribes audio into text
 
         Args:
-            file: The audio file object (not file name) to transcribe, in one of these formats:
-                flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
-                Can be a file path (str/Path), file object (BinaryIO), or URL (str).
-            model: ID of the model to use. Defaults to "openai/whisper-large-v3".
-            language: The language of the input audio. Supplying the input language in
-                ISO-639-1 format will improve accuracy and latency.
-            prompt: An optional text to guide the model's style or continue a previous
-                audio segment. The prompt should match the audio language.
-            response_format: The format of the transcript output, in one of these options:
-                json, verbose_json.
-            temperature: The sampling temperature, between 0 and 1. Higher values like 0.8
-                will make the output more random, while lower values like 0.2 will make it
-                more focused and deterministic.
-            timestamp_granularities: The timestamp granularities to populate for this
-                transcription. response_format must be set verbose_json to use timestamp
-                granularities. Either or both of these options are supported: word, or segment.
-            diarize: Whether to enable speaker diarization. When enabled, you will get the speaker id for each word in the transcription.
-                In the response, in the words array, you will get the speaker id for each word.
-                In addition, we also return the speaker_segments array which contains the speaker id for each speaker segment along with the start and end time of the segment along with all the words in the segment.
-                You can use the speaker_id to group the words by speaker.
-                You can use the speaker_segments to get the start and end time of each speaker segment.
-        Returns:
-            The transcribed text in the requested format.
-        """
+          file: Audio file to transcribe
 
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
+          diarize: Whether to enable speaker diarization. When enabled, you will get the speaker id
+              for each word in the transcription. In the response, in the words array, you
+              will get the speaker id for each word. In addition, we also return the
+              speaker_segments array which contains the speaker id for each speaker segment
+              along with the start and end time of the segment along with all the words in the
+              segment.
+
+              For eg - ... "speaker_segments": [ "speaker_id": "SPEAKER_00", "start": 0,
+              "end": 30.02, "words": [ { "id": 0, "word": "Tijana", "start": 0, "end": 11.475,
+              "speaker_id": "SPEAKER_00" }, ...
+
+          language: Optional ISO 639-1 language code. If `auto` is provided, language is
+              auto-detected.
+
+          model: Model to use for transcription
+
+          prompt: Optional text to bias decoding.
+
+          response_format: The format of the response
 
-        # Handle file input - could be a path, URL, or file object
-        files_data: Dict[str, Union[Tuple[None, str], BinaryIO]] = {}
-        params_data = {}
-
-        if isinstance(file, (str, Path)):
-            if isinstance(file, str) and file.startswith(("http://", "https://")):
-                # URL string - send as multipart field
-                files_data["file"] = (None, file)
-            else:
-                # Local file path
-                file_path = Path(file)
-                files_data["file"] = open(file_path, "rb")
-        else:
-            # File object
-            files_data["file"] = file
-
-        # Build request parameters
-        params_data.update(
+          temperature: Sampling temperature between 0.0 and 1.0
+
+          timestamp_granularities: Controls level of timestamp detail in verbose_json. Only used when
+              response_format is verbose_json. Can be a single granularity or an array to get
+              multiple levels.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        body = deepcopy_minimal(
             {
+                "file": file,
+                "diarize": diarize,
+                "language": language,
                 "model": model,
-                "response_format": (
-                    response_format
-                    if isinstance(response_format, str)
-                    else (
-                        response_format.value
-                        if hasattr(response_format, "value")
-                        else response_format
-                    )
-                ),
+                "prompt": prompt,
+                "response_format": response_format,
                 "temperature": temperature,
+                "timestamp_granularities": timestamp_granularities,
             }
         )
-
-        if language is not None:
-            params_data["language"] = language
-
-        if prompt is not None:
-            params_data["prompt"] = prompt
-
-        if timestamp_granularities is not None:
-            params_data["timestamp_granularities"] = (
-                timestamp_granularities
-                if isinstance(timestamp_granularities, str)
-                else (
-                    timestamp_granularities.value
-                    if hasattr(timestamp_granularities, "value")
-                    else timestamp_granularities
-                )
-            )
-
-        if diarize:
-            params_data["diarize"] = diarize
-
-        # Add any additional kwargs
-        # Convert boolean values to lowercase strings for proper form encoding
-        for key, value in kwargs.items():
-            if isinstance(value, bool):
-                params_data[key] = str(value).lower()
-            else:
-                params_data[key] = value
-
-        try:
-            response, _, _ = await requestor.arequest(
-                options=TogetherRequest(
-                    method="POST",
-                    url="audio/transcriptions",
-                    params=params_data,
-                    files=files_data,
+        files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
+        return cast(
+            TranscriptionCreateResponse,
+            await self._post(
+                "/audio/transcriptions",
+                body=await async_maybe_transform(body, transcription_create_params.TranscriptionCreateParams),
+                files=files,
+                options=make_request_options(
+                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
                 ),
-            )
-        finally:
-            # Close file if we opened it
-            if files_data and "file" in files_data:
-                try:
-                    # Only close if it's a file object (not a tuple for URL)
-                    file_obj = files_data["file"]
-                    if hasattr(file_obj, "close") and not isinstance(file_obj, tuple):
-                        file_obj.close()
-                except:
-                    pass
-
-        # Parse response based on format
-        if (
-            response_format == "verbose_json"
-            or response_format == AudioTranscriptionResponseFormat.VERBOSE_JSON
-            or diarize
-        ):
-            # Create response with model validation that preserves extra fields
-            return AudioTranscriptionVerboseResponse.model_validate(response.data)
-        else:
-            return AudioTranscriptionResponse(**response.data)
+                cast_to=cast(
+                    Any, TranscriptionCreateResponse
+                ),  # Union types cannot be passed in as arguments in the type system
+            ),
+        )
+
+
+class TranscriptionsResourceWithRawResponse:
+    def __init__(self, transcriptions: TranscriptionsResource) -> None:
+        self._transcriptions = transcriptions
+
+        self.create = to_raw_response_wrapper(
+            transcriptions.create,
+        )
+
+
+class AsyncTranscriptionsResourceWithRawResponse:
+    def __init__(self, transcriptions: AsyncTranscriptionsResource) -> None:
+        self._transcriptions = transcriptions
+
+        self.create = async_to_raw_response_wrapper(
+            transcriptions.create,
+        )
+
+
+class TranscriptionsResourceWithStreamingResponse:
+    def __init__(self, transcriptions: TranscriptionsResource) -> None:
+        self._transcriptions = transcriptions
+
+        self.create = to_streamed_response_wrapper(
+            transcriptions.create,
+        )
+
+
+class AsyncTranscriptionsResourceWithStreamingResponse:
+    def __init__(self, transcriptions: AsyncTranscriptionsResource) -> None:
+        self._transcriptions = transcriptions
+
+        self.create = async_to_streamed_response_wrapper(
+            transcriptions.create,
+        )