together 2.0.0a9__py3-none-any.whl → 2.0.0a10__py3-none-any.whl

together/resources/models.py

@@ -6,7 +6,7 @@ from typing_extensions import Literal
 
 import httpx
 
-from ..types import model_upload_params
+from ..types import model_list_params, model_upload_params
 from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
 from .._utils import maybe_transform, async_maybe_transform
 from .._compat import cached_property
@@ -47,6 +47,7 @@ class ModelsResource(SyncAPIResource):
     def list(
         self,
         *,
+        dedicated: bool | 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,
@@ -54,11 +55,28 @@ class ModelsResource(SyncAPIResource):
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ModelListResponse:
-        """Lists all of Together's open-source models"""
+        """
+        Lists all of Together's open-source models
+
+        Args:
+          dedicated: Filter models to only return dedicated models
+
+          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._get(
             "/models",
             options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"dedicated": dedicated}, model_list_params.ModelListParams),
             ),
             cast_to=ModelListResponse,
         )
@@ -152,6 +170,7 @@ class AsyncModelsResource(AsyncAPIResource):
     async def list(
         self,
         *,
+        dedicated: bool | 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,
@@ -159,11 +178,28 @@ class AsyncModelsResource(AsyncAPIResource):
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ModelListResponse:
-        """Lists all of Together's open-source models"""
+        """
+        Lists all of Together's open-source models
+
+        Args:
+          dedicated: Filter models to only return dedicated models
+
+          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._get(
             "/models",
             options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"dedicated": dedicated}, model_list_params.ModelListParams),
             ),
             cast_to=ModelListResponse,
         )

together/types/__init__.py

@@ -26,6 +26,7 @@ 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 .model_list_params import ModelListParams as ModelListParams
 from .tool_choice_param import ToolChoiceParam as ToolChoiceParam
 from .dedicated_endpoint import DedicatedEndpoint as DedicatedEndpoint
 from .eval_create_params import EvalCreateParams as EvalCreateParams
@@ -62,6 +63,8 @@ from .fine_tuning_delete_response import FineTuningDeleteResponse as FineTuningD
 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_estimate_price_params import FineTuningEstimatePriceParams as FineTuningEstimatePriceParams
+from .fine_tuning_estimate_price_response import FineTuningEstimatePriceResponse as FineTuningEstimatePriceResponse
 from .fine_tuning_list_checkpoints_response import (
     FineTuningListCheckpointsResponse as FineTuningListCheckpointsResponse,
 )

together/types/audio/voice_list_response.py

@@ -14,10 +14,14 @@ class DataVoice(BaseModel):
 
 
 class Data(BaseModel):
+    """Represents a model with its available voices."""
+
     model: str
 
     voices: List[DataVoice]
 
 
 class VoiceListResponse(BaseModel):
+    """Response containing a list of models and their available voices."""
+
     data: List[Data]

together/types/autoscaling.py

@@ -6,6 +6,8 @@ __all__ = ["Autoscaling"]
 
 
 class Autoscaling(BaseModel):
+    """Configuration for automatic scaling of replicas based on demand."""
+
     max_replicas: int
     """The maximum number of replicas to scale up to under load"""
 

together/types/autoscaling_param.py

@@ -8,6 +8,8 @@ __all__ = ["AutoscalingParam"]
 
 
 class AutoscalingParam(TypedDict, total=False):
+    """Configuration for automatic scaling of replicas based on demand."""
+
     max_replicas: Required[int]
     """The maximum number of replicas to scale up to under load"""
 

together/types/chat/completion_create_params.py

@@ -29,6 +29,10 @@ __all__ = [
     "FunctionCall",
     "FunctionCallName",
     "ResponseFormat",
+    "ResponseFormatText",
+    "ResponseFormatJsonSchema",
+    "ResponseFormatJsonSchemaJsonSchema",
+    "ResponseFormatJsonObject",
     "ToolChoice",
     "CompletionCreateParamsNonStreaming",
     "CompletionCreateParamsStreaming",
@@ -117,7 +121,16 @@ class CompletionCreateParamsBase(TypedDict, total=False):
     """
 
     response_format: ResponseFormat
-    """An object specifying the format that the model must output."""
+    """An object specifying the format that the model must output.
+
+    Setting to `{ "type": "json_schema", "json_schema": {...} }` enables Structured
+    Outputs which ensures the model will match your supplied JSON schema. Learn more
+    in the [Structured Outputs guide](https://docs.together.ai/docs/json-mode).
+
+    Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+    ensures the message the model generates is valid JSON. Using `json_schema` is
+    preferred for models that support it.
+    """
 
     safety_model: str
     """The name of the moderation model used to validate tokens.
@@ -297,13 +310,73 @@ class FunctionCallName(TypedDict, total=False):
 FunctionCall: TypeAlias = Union[Literal["none", "auto"], FunctionCallName]
 
 
-class ResponseFormat(TypedDict, total=False):
+class ResponseFormatText(TypedDict, total=False):
+    """Default response format. Used to generate text responses."""
+
+    type: Required[Literal["text"]]
+    """The type of response format being defined. Always `text`."""
+
+
+class ResponseFormatJsonSchemaJsonSchema(TypedDict, total=False):
+    """Structured Outputs configuration options, including a JSON Schema."""
+
+    name: Required[str]
+    """The name of the response format.
+
+    Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length
+    of 64.
+    """
+
+    description: str
+    """
+    A description of what the response format is for, used by the model to determine
+    how to respond in the format.
+    """
+
     schema: Dict[str, object]
-    """The schema of the response format."""
+    """
+    The schema for the response format, described as a JSON Schema object. Learn how
+    to build JSON schemas [here](https://json-schema.org/).
+    """
+
+    strict: Optional[bool]
+    """
+    Whether to enable strict schema adherence when generating the output. If set to
+    true, the model will always follow the exact schema defined in the `schema`
+    field. Only a subset of JSON Schema is supported when `strict` is `true`. To
+    learn more, read the
+    [Structured Outputs guide](https://docs.together.ai/docs/json-mode).
+    """
+
+
+class ResponseFormatJsonSchema(TypedDict, total=False):
+    """JSON Schema response format.
+
+    Used to generate structured JSON responses.
+    Learn more about [Structured Outputs](https://docs.together.ai/docs/json-mode).
+    """
+
+    json_schema: Required[ResponseFormatJsonSchemaJsonSchema]
+    """Structured Outputs configuration options, including a JSON Schema."""
+
+    type: Required[Literal["json_schema"]]
+    """The type of response format being defined. Always `json_schema`."""
+
+
+class ResponseFormatJsonObject(TypedDict, total=False):
+    """JSON object response format.
+
+    An older method of generating JSON responses.
+    Using `json_schema` is recommended for models that support it. Note that the
+    model will not generate JSON without a system or user message instructing it
+    to do so.
+    """
+
+    type: Required[Literal["json_object"]]
+    """The type of response format being defined. Always `json_object`."""
 
-    type: str
-    """The type of the response format."""
 
+ResponseFormat: TypeAlias = Union[ResponseFormatText, ResponseFormatJsonSchema, ResponseFormatJsonObject]
 
 ToolChoice: TypeAlias = Union[str, ToolChoiceParam]
 

together/types/dedicated_endpoint.py

@@ -10,6 +10,8 @@ __all__ = ["DedicatedEndpoint"]
 
 
 class DedicatedEndpoint(BaseModel):
+    """Details about a dedicated endpoint deployment"""
+
     id: str
     """Unique identifier for the endpoint"""
 

together/types/endpoint_list_avzones_response.py

@@ -8,4 +8,6 @@ __all__ = ["EndpointListAvzonesResponse"]
 
 
 class EndpointListAvzonesResponse(BaseModel):
+    """List of unique availability zones"""
+
     avzones: List[str]

together/types/endpoint_list_response.py

@@ -10,6 +10,8 @@ __all__ = ["EndpointListResponse", "Data"]
 
 
 class Data(BaseModel):
+    """Details about an endpoint when listed via the list endpoint"""
+
     id: str
     """Unique identifier for the endpoint"""
 

together/types/execute_response.py

@@ -22,12 +22,19 @@ __all__ = [
 
 
 class SuccessfulExecutionDataOutputStreamOutput(BaseModel):
+    """Outputs that were printed to stdout or stderr"""
+
     data: str
 
     type: Literal["stdout", "stderr"]
 
 
 class SuccessfulExecutionDataOutputError(BaseModel):
+    """Errors and exceptions that occurred.
+
+    If this output type is present, your code did not execute successfully.
+    """
+
     data: str
 
     type: Literal["error"]

together/types/fine_tuning_cancel_response.py

@@ -43,6 +43,8 @@ LrSchedulerLrSchedulerArgs: TypeAlias = Union[
 
 
 class LrScheduler(BaseModel):
+    """Learning rate scheduler configuration"""
+
     lr_scheduler_type: Literal["linear", "cosine"]
 
     lr_scheduler_args: Optional[LrSchedulerLrSchedulerArgs] = None
@@ -95,6 +97,10 @@ TrainingType: TypeAlias = Union[TrainingTypeFullTrainingType, TrainingTypeLoRaTr
 
 
 class FineTuningCancelResponse(BaseModel):
+    """
+    A truncated version of the fine-tune response, used for POST /fine-tunes, GET /fine-tunes and POST /fine-tunes/{id}/cancel endpoints
+    """
+
     id: str
     """Unique identifier for the fine-tune job"""
 

together/types/fine_tuning_estimate_price_params.py

@@ -0,0 +1,98 @@
+# 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, TypeAlias, TypedDict
+
+__all__ = [
+    "FineTuningEstimatePriceParams",
+    "TrainingMethod",
+    "TrainingMethodTrainingMethodSft",
+    "TrainingMethodTrainingMethodDpo",
+    "TrainingType",
+    "TrainingTypeFullTrainingType",
+    "TrainingTypeLoRaTrainingType",
+]
+
+
+class FineTuningEstimatePriceParams(TypedDict, total=False):
+    training_file: Required[str]
+    """File-ID of a training file uploaded to the Together API"""
+
+    from_checkpoint: str
+    """The checkpoint identifier to continue training from a previous fine-tuning job.
+
+    Format is `{$JOB_ID}` or `{$OUTPUT_MODEL_NAME}` or `{$JOB_ID}:{$STEP}` or
+    `{$OUTPUT_MODEL_NAME}:{$STEP}`. The step value is optional; without it, the
+    final checkpoint will be used.
+    """
+
+    model: str
+    """Name of the base model to run fine-tune job on"""
+
+    n_epochs: int
+    """
+    Number of complete passes through the training dataset (higher values may
+    improve results but increase cost and risk of overfitting)
+    """
+
+    n_evals: int
+    """Number of evaluations to be run on a given validation set during training"""
+
+    training_method: TrainingMethod
+    """The training method to use.
+
+    'sft' for Supervised Fine-Tuning or 'dpo' for Direct Preference Optimization.
+    """
+
+    training_type: TrainingType
+
+    validation_file: str
+    """File-ID of a validation file uploaded to the Together API"""
+
+
+class TrainingMethodTrainingMethodSft(TypedDict, total=False):
+    method: Required[Literal["sft"]]
+
+    train_on_inputs: Required[Union[bool, Literal["auto"]]]
+    """
+    Whether to mask the user messages in conversational data or prompts in
+    instruction data.
+    """
+
+
+class TrainingMethodTrainingMethodDpo(TypedDict, total=False):
+    method: Required[Literal["dpo"]]
+
+    dpo_beta: float
+
+    dpo_normalize_logratios_by_length: bool
+
+    dpo_reference_free: bool
+
+    rpo_alpha: float
+
+    simpo_gamma: float
+
+
+TrainingMethod: TypeAlias = Union[TrainingMethodTrainingMethodSft, TrainingMethodTrainingMethodDpo]
+
+
+class TrainingTypeFullTrainingType(TypedDict, total=False):
+    type: Required[Literal["Full"]]
+
+
+class TrainingTypeLoRaTrainingType(TypedDict, total=False):
+    lora_alpha: Required[int]
+
+    lora_r: Required[int]
+
+    type: Required[Literal["Lora"]]
+
+    lora_dropout: float
+
+    lora_trainable_modules: str
+
+
+TrainingType: TypeAlias = Union[TrainingTypeFullTrainingType, TrainingTypeLoRaTrainingType]

together/types/fine_tuning_estimate_price_response.py

@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .._models import BaseModel
+
+__all__ = ["FineTuningEstimatePriceResponse"]
+
+
+class FineTuningEstimatePriceResponse(BaseModel):
+    allowed_to_proceed: Optional[bool] = None
+    """Whether the user is allowed to proceed with the fine-tuning job"""
+
+    estimated_eval_token_count: Optional[float] = None
+    """The estimated number of tokens for evaluation"""
+
+    estimated_total_price: Optional[float] = None
+    """The price of the fine-tuning job"""
+
+    estimated_train_token_count: Optional[float] = None
+    """The estimated number of tokens to be trained"""
+
+    user_limit: Optional[float] = None
+    """The user's credit limit in dollars"""

together/types/fine_tuning_list_response.py

@@ -44,6 +44,8 @@ DataLrSchedulerLrSchedulerArgs: TypeAlias = Union[
 
 
 class DataLrScheduler(BaseModel):
+    """Learning rate scheduler configuration"""
+
     lr_scheduler_type: Literal["linear", "cosine"]
 
     lr_scheduler_args: Optional[DataLrSchedulerLrSchedulerArgs] = None
@@ -96,6 +98,10 @@ DataTrainingType: TypeAlias = Union[DataTrainingTypeFullTrainingType, DataTraini
 
 
 class Data(BaseModel):
+    """
+    A truncated version of the fine-tune response, used for POST /fine-tunes, GET /fine-tunes and POST /fine-tunes/{id}/cancel endpoints
+    """
+
     id: str
     """Unique identifier for the fine-tune job"""
 

together/types/hardware_list_response.py

@@ -10,11 +10,15 @@ __all__ = ["HardwareListResponse", "Data", "DataPricing", "DataSpecs", "DataAvai
 
 
 class DataPricing(BaseModel):
+    """Pricing details for using an endpoint"""
+
     cents_per_minute: float
     """Cost per minute of endpoint uptime in cents"""
 
 
 class DataSpecs(BaseModel):
+    """Detailed specifications of a hardware configuration"""
+
     gpu_count: int
     """Number of GPUs in this configuration"""
 
@@ -29,11 +33,15 @@ class DataSpecs(BaseModel):
 
 
 class DataAvailability(BaseModel):
+    """Indicates the current availability status of a hardware configuration"""
+
     status: Literal["available", "unavailable", "insufficient"]
     """The availability status of the hardware configuration"""
 
 
 class Data(BaseModel):
+    """Hardware configuration details with optional availability status"""
+
     id: str
     """Unique identifier for the hardware configuration"""
 

together/types/model_list_params.py

@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["ModelListParams"]
+
+
+class ModelListParams(TypedDict, total=False):
+    dedicated: bool
+    """Filter models to only return dedicated models"""

together/types/video_job.py

@@ -9,12 +9,18 @@ __all__ = ["VideoJob", "Error", "Outputs"]
 
 
 class Error(BaseModel):
+    """Error payload that explains why generation failed, if applicable."""
+
     message: str
 
     code: Optional[str] = None
 
 
 class Outputs(BaseModel):
+    """
+    Available upon completion, the outputs provides the cost charged and the hosted url to access the video
+    """
+
     cost: int
     """The cost of generated video charged to the owners account."""
 
@@ -23,6 +29,8 @@ class Outputs(BaseModel):
 
 
 class VideoJob(BaseModel):
+    """Structured information describing a generated video job."""
+
     id: str
     """Unique identifier for the video job."""
 

{together-2.0.0a9.dist-info → together-2.0.0a10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: together
-Version: 2.0.0a9
+Version: 2.0.0a10
 Summary: The official Python library for the together API
 Project-URL: Homepage, https://github.com/togethercomputer/together-py
 Project-URL: Repository, https://github.com/togethercomputer/together-py
@@ -232,17 +232,15 @@ from together import Together
 
 client = Together()
 
-chat_completion = client.chat.completions.create(
-    messages=[
-        {
-            "content": "content",
-            "role": "system",
-        }
-    ],
-    model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
-    response_format={},
+dedicated_endpoint = client.endpoints.create(
+    autoscaling={
+        "max_replicas": 5,
+        "min_replicas": 2,
+    },
+    hardware="1x_nvidia_a100_80gb_sxm",
+    model="meta-llama/Llama-3-8b-chat-hf",
 )
-print(chat_completion.response_format)
+print(dedicated_endpoint.autoscaling)
 ```
 
 The async client uses the exact same interface. If you pass a [`PathLike`](https://docs.python.org/3/library/os.html#os.PathLike) instance, the file contents will be read asynchronously automatically.