together 1.5.17__py3-none-any.whl → 2.0.0a8__py3-none-any.whl

together/resources/videos.py

@@ -0,0 +1,374 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable
+from typing_extensions import Literal
+
+import httpx
+
+from ..types import video_create_params
+from .._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
+from .._utils import maybe_transform, 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 .._base_client import make_request_options
+from ..types.video_job import VideoJob
+
+__all__ = ["VideosResource", "AsyncVideosResource"]
+
+
+class VideosResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> VideosResourceWithRawResponse:
+        """
+        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 VideosResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> VideosResourceWithStreamingResponse:
+        """
+        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 VideosResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        model: str,
+        fps: int | Omit = omit,
+        frame_images: Iterable[video_create_params.FrameImage] | Omit = omit,
+        guidance_scale: int | Omit = omit,
+        height: int | Omit = omit,
+        negative_prompt: str | Omit = omit,
+        output_format: Literal["MP4", "WEBM"] | Omit = omit,
+        output_quality: int | Omit = omit,
+        prompt: str | Omit = omit,
+        reference_images: SequenceNotStr[str] | Omit = omit,
+        seconds: str | Omit = omit,
+        seed: int | Omit = omit,
+        steps: int | Omit = omit,
+        width: int | 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,
+    ) -> VideoJob:
+        """
+        Create a video
+
+        Args:
+          model: The model to be used for the video creation request.
+
+          fps: Frames per second. Defaults to 24.
+
+          frame_images: Array of images to guide video generation, similar to keyframes.
+
+          guidance_scale: Controls how closely the video generation follows your prompt. Higher values
+              make the model adhere more strictly to your text description, while lower values
+              allow more creative freedom. guidence_scale affects both visual content and
+              temporal consistency.Recommended range is 6.0-10.0 for most video models. Values
+              above 12 may cause over-guidance artifacts or unnatural motion patterns.
+
+          negative_prompt: Similar to prompt, but specifies what to avoid instead of what to include
+
+          output_format: Specifies the format of the output video. Defaults to MP4.
+
+          output_quality: Compression quality. Defaults to 20.
+
+          prompt: Text prompt that describes the video to generate.
+
+          reference_images: Unlike frame_images which constrain specific timeline positions, reference
+              images guide the general appearance that should appear consistently across the
+              video.
+
+          seconds: Clip duration in seconds.
+
+          seed: Seed to use in initializing the video generation. Using the same seed allows
+              deterministic video generation. If not provided a random seed is generated for
+              each request.
+
+          steps: The number of denoising steps the model performs during video generation. More
+              steps typically result in higher quality output but require longer processing
+              time.
+
+          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
+        """
+        return self._post(
+            "/videos" if self._client._base_url_overridden else "https://api.together.xyz/v2/videos",
+            body=maybe_transform(
+                {
+                    "model": model,
+                    "fps": fps,
+                    "frame_images": frame_images,
+                    "guidance_scale": guidance_scale,
+                    "height": height,
+                    "negative_prompt": negative_prompt,
+                    "output_format": output_format,
+                    "output_quality": output_quality,
+                    "prompt": prompt,
+                    "reference_images": reference_images,
+                    "seconds": seconds,
+                    "seed": seed,
+                    "steps": steps,
+                    "width": width,
+                },
+                video_create_params.VideoCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=VideoJob,
+        )
+
+    def retrieve(
+        self,
+        id: str,
+        *,
+        # 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,
+    ) -> VideoJob:
+        """
+        Fetch video metadata
+
+        Args:
+          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
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return self._get(
+            f"/videos/{id}" if self._client._base_url_overridden else f"https://api.together.xyz/v2/videos/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=VideoJob,
+        )
+
+
+class AsyncVideosResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncVideosResourceWithRawResponse:
+        """
+        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 AsyncVideosResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncVideosResourceWithStreamingResponse:
+        """
+        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 AsyncVideosResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        model: str,
+        fps: int | Omit = omit,
+        frame_images: Iterable[video_create_params.FrameImage] | Omit = omit,
+        guidance_scale: int | Omit = omit,
+        height: int | Omit = omit,
+        negative_prompt: str | Omit = omit,
+        output_format: Literal["MP4", "WEBM"] | Omit = omit,
+        output_quality: int | Omit = omit,
+        prompt: str | Omit = omit,
+        reference_images: SequenceNotStr[str] | Omit = omit,
+        seconds: str | Omit = omit,
+        seed: int | Omit = omit,
+        steps: int | Omit = omit,
+        width: int | 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,
+    ) -> VideoJob:
+        """
+        Create a video
+
+        Args:
+          model: The model to be used for the video creation request.
+
+          fps: Frames per second. Defaults to 24.
+
+          frame_images: Array of images to guide video generation, similar to keyframes.
+
+          guidance_scale: Controls how closely the video generation follows your prompt. Higher values
+              make the model adhere more strictly to your text description, while lower values
+              allow more creative freedom. guidence_scale affects both visual content and
+              temporal consistency.Recommended range is 6.0-10.0 for most video models. Values
+              above 12 may cause over-guidance artifacts or unnatural motion patterns.
+
+          negative_prompt: Similar to prompt, but specifies what to avoid instead of what to include
+
+          output_format: Specifies the format of the output video. Defaults to MP4.
+
+          output_quality: Compression quality. Defaults to 20.
+
+          prompt: Text prompt that describes the video to generate.
+
+          reference_images: Unlike frame_images which constrain specific timeline positions, reference
+              images guide the general appearance that should appear consistently across the
+              video.
+
+          seconds: Clip duration in seconds.
+
+          seed: Seed to use in initializing the video generation. Using the same seed allows
+              deterministic video generation. If not provided a random seed is generated for
+              each request.
+
+          steps: The number of denoising steps the model performs during video generation. More
+              steps typically result in higher quality output but require longer processing
+              time.
+
+          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
+        """
+        return await self._post(
+            "/videos" if self._client._base_url_overridden else "https://api.together.xyz/v2/videos",
+            body=await async_maybe_transform(
+                {
+                    "model": model,
+                    "fps": fps,
+                    "frame_images": frame_images,
+                    "guidance_scale": guidance_scale,
+                    "height": height,
+                    "negative_prompt": negative_prompt,
+                    "output_format": output_format,
+                    "output_quality": output_quality,
+                    "prompt": prompt,
+                    "reference_images": reference_images,
+                    "seconds": seconds,
+                    "seed": seed,
+                    "steps": steps,
+                    "width": width,
+                },
+                video_create_params.VideoCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=VideoJob,
+        )
+
+    async def retrieve(
+        self,
+        id: str,
+        *,
+        # 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,
+    ) -> VideoJob:
+        """
+        Fetch video metadata
+
+        Args:
+          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
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return await self._get(
+            f"/videos/{id}" if self._client._base_url_overridden else f"https://api.together.xyz/v2/videos/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=VideoJob,
+        )
+
+
+class VideosResourceWithRawResponse:
+    def __init__(self, videos: VideosResource) -> None:
+        self._videos = videos
+
+        self.create = to_raw_response_wrapper(
+            videos.create,
+        )
+        self.retrieve = to_raw_response_wrapper(
+            videos.retrieve,
+        )
+
+
+class AsyncVideosResourceWithRawResponse:
+    def __init__(self, videos: AsyncVideosResource) -> None:
+        self._videos = videos
+
+        self.create = async_to_raw_response_wrapper(
+            videos.create,
+        )
+        self.retrieve = async_to_raw_response_wrapper(
+            videos.retrieve,
+        )
+
+
+class VideosResourceWithStreamingResponse:
+    def __init__(self, videos: VideosResource) -> None:
+        self._videos = videos
+
+        self.create = to_streamed_response_wrapper(
+            videos.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            videos.retrieve,
+        )
+
+
+class AsyncVideosResourceWithStreamingResponse:
+    def __init__(self, videos: AsyncVideosResource) -> None:
+        self._videos = videos
+
+        self.create = async_to_streamed_response_wrapper(
+            videos.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            videos.retrieve,
+        )

together/types/__init__.py

@@ -1,111 +1,67 @@
-from together.types.abstract import TogetherClient
-from together.types.audio_speech import (
-    AudioLanguage,
-    AudioResponseEncoding,
-    AudioResponseFormat,
-    AudioSpeechRequest,
-    AudioSpeechStreamChunk,
-    AudioSpeechStreamEvent,
-    AudioSpeechStreamResponse,
-)
-from together.types.chat_completions import (
-    ChatCompletionChunk,
-    ChatCompletionRequest,
-    ChatCompletionResponse,
-)
-from together.types.common import TogetherRequest
-from together.types.completions import (
-    CompletionChunk,
-    CompletionRequest,
-    CompletionResponse,
-)
-from together.types.embeddings import EmbeddingRequest, EmbeddingResponse
-from together.types.endpoints import Autoscaling, DedicatedEndpoint, ListEndpoint
-from together.types.files import (
-    FileDeleteResponse,
-    FileList,
-    FileObject,
-    FilePurpose,
-    FileRequest,
-    FileResponse,
-    FileType,
-)
-from together.types.finetune import (
-    TrainingMethodDPO,
-    TrainingMethodSFT,
-    FinetuneCheckpoint,
-    CosineLRScheduler,
-    CosineLRSchedulerArgs,
-    FinetuneDownloadResult,
-    LinearLRScheduler,
-    LinearLRSchedulerArgs,
-    FinetuneLRScheduler,
-    FinetuneList,
-    FinetuneListEvents,
-    FinetuneRequest,
-    FinetuneResponse,
-    FinetuneTrainingLimits,
-    FullTrainingType,
-    LoRATrainingType,
-    TrainingType,
-)
-from together.types.images import ImageRequest, ImageResponse
-from together.types.models import ModelObject
-from together.types.rerank import RerankRequest, RerankResponse
-from together.types.batch import BatchJob, BatchJobStatus, BatchEndpoint
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from __future__ import annotations
 
-__all__ = [
-    "TogetherClient",
-    "TogetherRequest",
-    "CompletionChunk",
-    "CompletionRequest",
-    "CompletionResponse",
-    "ChatCompletionChunk",
-    "ChatCompletionRequest",
-    "ChatCompletionResponse",
-    "EmbeddingRequest",
-    "EmbeddingResponse",
-    "FinetuneCheckpoint",
-    "FinetuneRequest",
-    "FinetuneResponse",
-    "FinetuneList",
-    "FinetuneListEvents",
-    "FinetuneDownloadResult",
-    "FinetuneLRScheduler",
-    "LinearLRScheduler",
-    "LinearLRSchedulerArgs",
-    "CosineLRScheduler",
-    "CosineLRSchedulerArgs",
-    "FileRequest",
-    "FileResponse",
-    "FileList",
-    "FileDeleteResponse",
-    "FileObject",
-    "FilePurpose",
-    "FileType",
-    "ImageRequest",
-    "ImageResponse",
-    "ModelObject",
-    "TrainingType",
-    "FullTrainingType",
-    "LoRATrainingType",
-    "TrainingMethodDPO",
-    "TrainingMethodSFT",
-    "RerankRequest",
-    "RerankResponse",
-    "FinetuneTrainingLimits",
-    "AudioSpeechRequest",
-    "AudioResponseFormat",
-    "AudioLanguage",
-    "AudioResponseEncoding",
-    "AudioSpeechStreamChunk",
-    "AudioSpeechStreamEvent",
-    "AudioSpeechStreamResponse",
-    "DedicatedEndpoint",
-    "ListEndpoint",
-    "Autoscaling",
-    "BatchJob",
-    "BatchJobStatus",
-    "BatchEndpoint",
-]
+from .batch_job import BatchJob as BatchJob
+from .embedding import Embedding as Embedding
+from .file_list import FileList as FileList
+from .file_type import FileType as FileType
+from .log_probs import LogProbs as LogProbs
+from .video_job import VideoJob as VideoJob
+from .completion import Completion as Completion
+from .image_file import ImageFile as ImageFile
+from .autoscaling import Autoscaling as Autoscaling
+from .tool_choice import ToolChoice as ToolChoice
+from .tools_param import ToolsParam as ToolsParam
+from .file_purpose import FilePurpose as FilePurpose
+from .model_object import ModelObject as ModelObject
+from .file_response import FileResponse as FileResponse
+from .evaluation_job import EvaluationJob as EvaluationJob
+from .finetune_event import FinetuneEvent as FinetuneEvent
+from .image_data_b64 import ImageDataB64 as ImageDataB64
+from .image_data_url import ImageDataURL as ImageDataURL
+from .completion_chunk import CompletionChunk as CompletionChunk
+from .eval_list_params import EvalListParams as EvalListParams
+from .execute_response import ExecuteResponse as ExecuteResponse
+from .autoscaling_param import AutoscalingParam as AutoscalingParam
+from .finetune_response import FinetuneResponse as FinetuneResponse
+from .job_list_response import JobListResponse as JobListResponse
+from .tool_choice_param import ToolChoiceParam as ToolChoiceParam
+from .dedicated_endpoint import DedicatedEndpoint as DedicatedEndpoint
+from .eval_create_params import EvalCreateParams as EvalCreateParams
+from .eval_list_response import EvalListResponse as EvalListResponse
+from .batch_create_params import BatchCreateParams as BatchCreateParams
+from .batch_list_response import BatchListResponse as BatchListResponse
+from .finetune_event_type import FinetuneEventType as FinetuneEventType
+from .model_list_response import ModelListResponse as ModelListResponse
+from .model_upload_params import ModelUploadParams as ModelUploadParams
+from .video_create_params import VideoCreateParams as VideoCreateParams
+from .endpoint_list_params import EndpointListParams as EndpointListParams
+from .eval_create_response import EvalCreateResponse as EvalCreateResponse
+from .eval_status_response import EvalStatusResponse as EvalStatusResponse
+from .file_delete_response import FileDeleteResponse as FileDeleteResponse
+from .hardware_list_params import HardwareListParams as HardwareListParams
+from .rerank_create_params import RerankCreateParams as RerankCreateParams
+from .batch_create_response import BatchCreateResponse as BatchCreateResponse
+from .image_generate_params import ImageGenerateParams as ImageGenerateParams
+from .job_retrieve_response import JobRetrieveResponse as JobRetrieveResponse
+from .model_upload_response import ModelUploadResponse as ModelUploadResponse
+from .endpoint_create_params import EndpointCreateParams as EndpointCreateParams
+from .endpoint_list_response import EndpointListResponse as EndpointListResponse
+from .endpoint_update_params import EndpointUpdateParams as EndpointUpdateParams
+from .hardware_list_response import HardwareListResponse as HardwareListResponse
+from .rerank_create_response import RerankCreateResponse as RerankCreateResponse
+from .embedding_create_params import EmbeddingCreateParams as EmbeddingCreateParams
+from .completion_create_params import CompletionCreateParams as CompletionCreateParams
+from .audio_speech_stream_chunk import AudioSpeechStreamChunk as AudioSpeechStreamChunk
+from .fine_tuning_delete_params import FineTuningDeleteParams as FineTuningDeleteParams
+from .fine_tuning_list_response import FineTuningListResponse as FineTuningListResponse
+from .fine_tuning_content_params import FineTuningContentParams as FineTuningContentParams
+from .fine_tuning_cancel_response import FineTuningCancelResponse as FineTuningCancelResponse
+from .fine_tuning_delete_response import FineTuningDeleteResponse as FineTuningDeleteResponse
+from .endpoint_list_avzones_response import EndpointListAvzonesResponse as EndpointListAvzonesResponse
+from .code_interpreter_execute_params import CodeInterpreterExecuteParams as CodeInterpreterExecuteParams
+from .fine_tuning_list_events_response import FineTuningListEventsResponse as FineTuningListEventsResponse
+from .fine_tuning_list_checkpoints_response import (
+    FineTuningListCheckpointsResponse as FineTuningListCheckpointsResponse,
+)

together/types/audio/__init__.py

@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .voice_list_response import VoiceListResponse as VoiceListResponse
+from .speech_create_params import SpeechCreateParams as SpeechCreateParams
+from .translation_create_params import TranslationCreateParams as TranslationCreateParams
+from .transcription_create_params import TranscriptionCreateParams as TranscriptionCreateParams
+from .translation_create_response import TranslationCreateResponse as TranslationCreateResponse
+from .transcription_create_response import TranscriptionCreateResponse as TranscriptionCreateResponse

together/types/audio/speech_create_params.py

@@ -0,0 +1,75 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["SpeechCreateParamsBase", "SpeechCreateParamsNonStreaming", "SpeechCreateParamsStreaming"]
+
+
+class SpeechCreateParamsBase(TypedDict, total=False):
+    input: Required[str]
+    """Input text to generate the audio for"""
+
+    model: Required[Union[Literal["cartesia/sonic", "hexgrad/Kokoro-82M", "canopylabs/orpheus-3b-0.1-ft"], str]]
+    """The name of the model to query.
+
+    [See all of Together AI's chat models](https://docs.together.ai/docs/serverless-models#audio-models)
+    The current supported tts models are: - cartesia/sonic - hexgrad/Kokoro-82M -
+    canopylabs/orpheus-3b-0.1-ft
+    """
+
+    voice: Required[str]
+    """The voice to use for generating the audio.
+
+    The voices supported are different for each model. For eg - for
+    canopylabs/orpheus-3b-0.1-ft, one of the voices supported is tara, for
+    hexgrad/Kokoro-82M, one of the voices supported is af_alloy and for
+    cartesia/sonic, one of the voices supported is "friendly sidekick".
+
+    You can view the voices supported for each model using the /v1/voices endpoint
+    sending the model name as the query parameter.
+    [View all supported voices here](https://docs.together.ai/docs/text-to-speech#voices-available).
+    """
+
+    language: Literal["en", "de", "fr", "es", "hi", "it", "ja", "ko", "nl", "pl", "pt", "ru", "sv", "tr", "zh"]
+    """Language of input text."""
+
+    response_encoding: Literal["pcm_f32le", "pcm_s16le", "pcm_mulaw", "pcm_alaw"]
+    """Audio encoding of response"""
+
+    response_format: Literal["mp3", "wav", "raw"]
+    """The format of audio output.
+
+    Supported formats are mp3, wav, raw if streaming is false. If streaming is true,
+    the only supported format is raw.
+    """
+
+    sample_rate: int
+    """Sampling rate to use for the output audio.
+
+    The default sampling rate for canopylabs/orpheus-3b-0.1-ft and
+    hexgrad/Kokoro-82M is 24000 and for cartesia/sonic is 44100.
+    """
+
+
+class SpeechCreateParamsNonStreaming(SpeechCreateParamsBase, total=False):
+    stream: Literal[False]
+    """
+    If true, output is streamed for several characters at a time instead of waiting
+    for the full response. The stream terminates with `data: [DONE]`. If false,
+    return the encoded audio as octet stream
+    """
+
+
+class SpeechCreateParamsStreaming(SpeechCreateParamsBase):
+    stream: Required[Literal[True]]
+    """
+    If true, output is streamed for several characters at a time instead of waiting
+    for the full response. The stream terminates with `data: [DONE]`. If false,
+    return the encoded audio as octet stream
+    """
+
+
+SpeechCreateParams = Union[SpeechCreateParamsNonStreaming, SpeechCreateParamsStreaming]