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

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

@@ -15,6 +15,7 @@ __all__ = [
     "LrSchedulerLrSchedulerArgs",
     "LrSchedulerLrSchedulerArgsLinearLrSchedulerArgs",
     "LrSchedulerLrSchedulerArgsCosineLrSchedulerArgs",
+    "Progress",
     "TrainingMethod",
     "TrainingMethodTrainingMethodSft",
     "TrainingMethodTrainingMethodDpo",
@@ -43,11 +44,23 @@ LrSchedulerLrSchedulerArgs: TypeAlias = Union[
 
 
 class LrScheduler(BaseModel):
+    """Learning rate scheduler configuration"""
+
     lr_scheduler_type: Literal["linear", "cosine"]
 
     lr_scheduler_args: Optional[LrSchedulerLrSchedulerArgs] = None
 
 
+class Progress(BaseModel):
+    """Progress information for the fine-tuning job"""
+
+    estimate_available: bool
+    """Whether time estimate is available"""
+
+    seconds_remaining: int
+    """Estimated time remaining in seconds for the fine-tuning job to next state"""
+
+
 class TrainingMethodTrainingMethodSft(BaseModel):
     method: Literal["sft"]
 
@@ -95,6 +108,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"""
 
@@ -157,6 +174,9 @@ class FineTuningCancelResponse(BaseModel):
     owner_address: Optional[str] = None
     """Owner address information"""
 
+    progress: Optional[Progress] = None
+    """Progress information for the fine-tuning job"""
+
     suffix: Optional[str] = None
     """Suffix added to the fine-tuned model name"""
 

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

@@ -16,6 +16,7 @@ __all__ = [
     "DataLrSchedulerLrSchedulerArgs",
     "DataLrSchedulerLrSchedulerArgsLinearLrSchedulerArgs",
     "DataLrSchedulerLrSchedulerArgsCosineLrSchedulerArgs",
+    "DataProgress",
     "DataTrainingMethod",
     "DataTrainingMethodTrainingMethodSft",
     "DataTrainingMethodTrainingMethodDpo",
@@ -44,11 +45,23 @@ DataLrSchedulerLrSchedulerArgs: TypeAlias = Union[
 
 
 class DataLrScheduler(BaseModel):
+    """Learning rate scheduler configuration"""
+
     lr_scheduler_type: Literal["linear", "cosine"]
 
     lr_scheduler_args: Optional[DataLrSchedulerLrSchedulerArgs] = None
 
 
+class DataProgress(BaseModel):
+    """Progress information for the fine-tuning job"""
+
+    estimate_available: bool
+    """Whether time estimate is available"""
+
+    seconds_remaining: int
+    """Estimated time remaining in seconds for the fine-tuning job to next state"""
+
+
 class DataTrainingMethodTrainingMethodSft(BaseModel):
     method: Literal["sft"]
 
@@ -96,6 +109,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"""
 
@@ -158,6 +175,9 @@ class Data(BaseModel):
     owner_address: Optional[str] = None
     """Owner address information"""
 
+    progress: Optional[DataProgress] = None
+    """Progress information for the fine-tuning job"""
+
     suffix: Optional[str] = None
     """Suffix added to the fine-tuned model name"""
 

together/types/finetune_response.py

@@ -1,6 +1,7 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 from typing import List, Union, Optional
+from datetime import datetime
 from typing_extensions import Literal, TypeAlias
 
 from pydantic import Field as FieldInfo
@@ -14,6 +15,7 @@ __all__ = [
     "LrSchedulerLrSchedulerArgs",
     "LrSchedulerLrSchedulerArgsLinearLrSchedulerArgs",
     "LrSchedulerLrSchedulerArgsCosineLrSchedulerArgs",
+    "Progress",
     "TrainingMethod",
     "TrainingMethodTrainingMethodSft",
     "TrainingMethodTrainingMethodDpo",
@@ -47,6 +49,16 @@ class LrScheduler(BaseModel):
     lr_scheduler_args: Optional[LrSchedulerLrSchedulerArgs] = None
 
 
+class Progress(BaseModel):
+    """Progress information for a fine-tuning job"""
+
+    estimate_available: bool
+    """Whether time estimate is available"""
+
+    seconds_remaining: int
+    """Estimated time remaining in seconds for the fine-tuning job to next state"""
+
+
 class TrainingMethodTrainingMethodSft(BaseModel):
     method: Literal["sft"]
 
@@ -110,7 +122,7 @@ class FinetuneResponse(BaseModel):
 
     batch_size: Union[int, Literal["max"], None] = None
 
-    created_at: Optional[str] = None
+    created_at: Optional[datetime] = None
 
     epochs_completed: Optional[int] = None
 
@@ -146,6 +158,9 @@ class FinetuneResponse(BaseModel):
 
     param_count: Optional[int] = None
 
+    progress: Optional[Progress] = None
+    """Progress information for a fine-tuning job"""
+
     queue_depth: Optional[int] = None
 
     token_count: Optional[int] = None
@@ -164,7 +179,7 @@ class FinetuneResponse(BaseModel):
 
     trainingfile_size: Optional[int] = None
 
-    updated_at: Optional[str] = None
+    updated_at: Optional[datetime] = None
 
     validation_file: Optional[str] = None
 

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.0a11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: together
-Version: 2.0.0a9
+Version: 2.0.0a11
 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.