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

together/types/fine_tuning_list_response.py

@@ -0,0 +1,199 @@
+# 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
+
+from .._models import BaseModel
+from .finetune_event import FinetuneEvent
+
+__all__ = [
+    "FineTuningListResponse",
+    "Data",
+    "DataLrScheduler",
+    "DataLrSchedulerLrSchedulerArgs",
+    "DataLrSchedulerLrSchedulerArgsLinearLrSchedulerArgs",
+    "DataLrSchedulerLrSchedulerArgsCosineLrSchedulerArgs",
+    "DataTrainingMethod",
+    "DataTrainingMethodTrainingMethodSft",
+    "DataTrainingMethodTrainingMethodDpo",
+    "DataTrainingType",
+    "DataTrainingTypeFullTrainingType",
+    "DataTrainingTypeLoRaTrainingType",
+]
+
+
+class DataLrSchedulerLrSchedulerArgsLinearLrSchedulerArgs(BaseModel):
+    min_lr_ratio: Optional[float] = None
+    """The ratio of the final learning rate to the peak learning rate"""
+
+
+class DataLrSchedulerLrSchedulerArgsCosineLrSchedulerArgs(BaseModel):
+    min_lr_ratio: float
+    """The ratio of the final learning rate to the peak learning rate"""
+
+    num_cycles: float
+    """Number or fraction of cycles for the cosine learning rate scheduler"""
+
+
+DataLrSchedulerLrSchedulerArgs: TypeAlias = Union[
+    DataLrSchedulerLrSchedulerArgsLinearLrSchedulerArgs, DataLrSchedulerLrSchedulerArgsCosineLrSchedulerArgs
+]
+
+
+class DataLrScheduler(BaseModel):
+    lr_scheduler_type: Literal["linear", "cosine"]
+
+    lr_scheduler_args: Optional[DataLrSchedulerLrSchedulerArgs] = None
+
+
+class DataTrainingMethodTrainingMethodSft(BaseModel):
+    method: Literal["sft"]
+
+    train_on_inputs: Union[bool, Literal["auto"]]
+    """
+    Whether to mask the user messages in conversational data or prompts in
+    instruction data.
+    """
+
+
+class DataTrainingMethodTrainingMethodDpo(BaseModel):
+    method: Literal["dpo"]
+
+    dpo_beta: Optional[float] = None
+
+    dpo_normalize_logratios_by_length: Optional[bool] = None
+
+    dpo_reference_free: Optional[bool] = None
+
+    rpo_alpha: Optional[float] = None
+
+    simpo_gamma: Optional[float] = None
+
+
+DataTrainingMethod: TypeAlias = Union[DataTrainingMethodTrainingMethodSft, DataTrainingMethodTrainingMethodDpo]
+
+
+class DataTrainingTypeFullTrainingType(BaseModel):
+    type: Literal["Full"]
+
+
+class DataTrainingTypeLoRaTrainingType(BaseModel):
+    lora_alpha: int
+
+    lora_r: int
+
+    type: Literal["Lora"]
+
+    lora_dropout: Optional[float] = None
+
+    lora_trainable_modules: Optional[str] = None
+
+
+DataTrainingType: TypeAlias = Union[DataTrainingTypeFullTrainingType, DataTrainingTypeLoRaTrainingType]
+
+
+class Data(BaseModel):
+    id: str
+    """Unique identifier for the fine-tune job"""
+
+    created_at: datetime
+    """Creation timestamp of the fine-tune job"""
+
+    status: Literal[
+        "pending",
+        "queued",
+        "running",
+        "compressing",
+        "uploading",
+        "cancel_requested",
+        "cancelled",
+        "error",
+        "completed",
+    ]
+
+    updated_at: datetime
+    """Last update timestamp of the fine-tune job"""
+
+    batch_size: Optional[int] = None
+    """Batch size used for training"""
+
+    events: Optional[List[FinetuneEvent]] = None
+    """Events related to this fine-tune job"""
+
+    from_checkpoint: Optional[str] = None
+    """Checkpoint used to continue training"""
+
+    from_hf_model: Optional[str] = None
+    """Hugging Face Hub repo to start training from"""
+
+    hf_model_revision: Optional[str] = None
+    """The revision of the Hugging Face Hub model to continue training from"""
+
+    learning_rate: Optional[float] = None
+    """Learning rate used for training"""
+
+    lr_scheduler: Optional[DataLrScheduler] = None
+    """Learning rate scheduler configuration"""
+
+    max_grad_norm: Optional[float] = None
+    """Maximum gradient norm for clipping"""
+
+    model: Optional[str] = None
+    """Base model used for fine-tuning"""
+
+    x_model_output_name: Optional[str] = FieldInfo(alias="model_output_name", default=None)
+
+    n_checkpoints: Optional[int] = None
+    """Number of checkpoints saved during training"""
+
+    n_epochs: Optional[int] = None
+    """Number of training epochs"""
+
+    n_evals: Optional[int] = None
+    """Number of evaluations during training"""
+
+    owner_address: Optional[str] = None
+    """Owner address information"""
+
+    suffix: Optional[str] = None
+    """Suffix added to the fine-tuned model name"""
+
+    token_count: Optional[int] = None
+    """Count of tokens processed"""
+
+    total_price: Optional[int] = None
+    """Total price for the fine-tuning job"""
+
+    training_file: Optional[str] = None
+    """File-ID of the training file"""
+
+    training_method: Optional[DataTrainingMethod] = None
+    """Method of training used"""
+
+    training_type: Optional[DataTrainingType] = None
+    """Type of training used (full or LoRA)"""
+
+    user_id: Optional[str] = None
+    """Identifier for the user who created the job"""
+
+    validation_file: Optional[str] = None
+    """File-ID of the validation file"""
+
+    wandb_name: Optional[str] = None
+    """Weights & Biases run name"""
+
+    wandb_project_name: Optional[str] = None
+    """Weights & Biases project name"""
+
+    warmup_ratio: Optional[float] = None
+    """Ratio of warmup steps"""
+
+    weight_decay: Optional[float] = None
+    """Weight decay value used"""
+
+
+class FineTuningListResponse(BaseModel):
+    data: List[Data]

together/types/finetune_event.py

@@ -0,0 +1,41 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+from .finetune_event_type import FinetuneEventType
+
+__all__ = ["FinetuneEvent"]
+
+
+class FinetuneEvent(BaseModel):
+    checkpoint_path: str
+
+    created_at: str
+
+    hash: str
+
+    message: str
+
+    x_model_path: str = FieldInfo(alias="model_path")
+
+    object: Literal["fine-tune-event"]
+
+    param_count: int
+
+    step: int
+
+    token_count: int
+
+    total_steps: int
+
+    training_offset: int
+
+    type: FinetuneEventType
+
+    wandb_url: str
+
+    level: Optional[Literal["info", "warning", "error", "legacy_info", "legacy_iwarning", "legacy_ierror"]] = None

together/types/finetune_event_type.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["FinetuneEventType"]
+
+FinetuneEventType: TypeAlias = Literal[
+    "job_pending",
+    "job_start",
+    "job_stopped",
+    "model_downloading",
+    "model_download_complete",
+    "training_data_downloading",
+    "training_data_download_complete",
+    "validation_data_downloading",
+    "validation_data_download_complete",
+    "wandb_init",
+    "training_start",
+    "checkpoint_save",
+    "billing_limit",
+    "epoch_complete",
+    "training_complete",
+    "model_compressing",
+    "model_compression_complete",
+    "model_uploading",
+    "model_upload_complete",
+    "job_complete",
+    "job_error",
+    "cancel_requested",
+    "job_restarted",
+    "refund",
+    "warning",
+]

together/types/finetune_response.py

@@ -0,0 +1,177 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+from .finetune_event import FinetuneEvent
+
+__all__ = [
+    "FinetuneResponse",
+    "LrScheduler",
+    "LrSchedulerLrSchedulerArgs",
+    "LrSchedulerLrSchedulerArgsLinearLrSchedulerArgs",
+    "LrSchedulerLrSchedulerArgsCosineLrSchedulerArgs",
+    "TrainingMethod",
+    "TrainingMethodTrainingMethodSft",
+    "TrainingMethodTrainingMethodDpo",
+    "TrainingType",
+    "TrainingTypeFullTrainingType",
+    "TrainingTypeLoRaTrainingType",
+]
+
+
+class LrSchedulerLrSchedulerArgsLinearLrSchedulerArgs(BaseModel):
+    min_lr_ratio: Optional[float] = None
+    """The ratio of the final learning rate to the peak learning rate"""
+
+
+class LrSchedulerLrSchedulerArgsCosineLrSchedulerArgs(BaseModel):
+    min_lr_ratio: float
+    """The ratio of the final learning rate to the peak learning rate"""
+
+    num_cycles: float
+    """Number or fraction of cycles for the cosine learning rate scheduler"""
+
+
+LrSchedulerLrSchedulerArgs: TypeAlias = Union[
+    LrSchedulerLrSchedulerArgsLinearLrSchedulerArgs, LrSchedulerLrSchedulerArgsCosineLrSchedulerArgs
+]
+
+
+class LrScheduler(BaseModel):
+    lr_scheduler_type: Literal["linear", "cosine"]
+
+    lr_scheduler_args: Optional[LrSchedulerLrSchedulerArgs] = None
+
+
+class TrainingMethodTrainingMethodSft(BaseModel):
+    method: Literal["sft"]
+
+    train_on_inputs: Union[bool, Literal["auto"]]
+    """
+    Whether to mask the user messages in conversational data or prompts in
+    instruction data.
+    """
+
+
+class TrainingMethodTrainingMethodDpo(BaseModel):
+    method: Literal["dpo"]
+
+    dpo_beta: Optional[float] = None
+
+    dpo_normalize_logratios_by_length: Optional[bool] = None
+
+    dpo_reference_free: Optional[bool] = None
+
+    rpo_alpha: Optional[float] = None
+
+    simpo_gamma: Optional[float] = None
+
+
+TrainingMethod: TypeAlias = Union[TrainingMethodTrainingMethodSft, TrainingMethodTrainingMethodDpo]
+
+
+class TrainingTypeFullTrainingType(BaseModel):
+    type: Literal["Full"]
+
+
+class TrainingTypeLoRaTrainingType(BaseModel):
+    lora_alpha: int
+
+    lora_r: int
+
+    type: Literal["Lora"]
+
+    lora_dropout: Optional[float] = None
+
+    lora_trainable_modules: Optional[str] = None
+
+
+TrainingType: TypeAlias = Union[TrainingTypeFullTrainingType, TrainingTypeLoRaTrainingType]
+
+
+class FinetuneResponse(BaseModel):
+    id: str
+
+    status: Literal[
+        "pending",
+        "queued",
+        "running",
+        "compressing",
+        "uploading",
+        "cancel_requested",
+        "cancelled",
+        "error",
+        "completed",
+    ]
+
+    batch_size: Union[int, Literal["max"], None] = None
+
+    created_at: Optional[str] = None
+
+    epochs_completed: Optional[int] = None
+
+    eval_steps: Optional[int] = None
+
+    events: Optional[List[FinetuneEvent]] = None
+
+    from_checkpoint: Optional[str] = None
+
+    from_hf_model: Optional[str] = None
+
+    hf_model_revision: Optional[str] = None
+
+    job_id: Optional[str] = None
+
+    learning_rate: Optional[float] = None
+
+    lr_scheduler: Optional[LrScheduler] = None
+
+    max_grad_norm: Optional[float] = None
+
+    model: Optional[str] = None
+
+    x_model_output_name: Optional[str] = FieldInfo(alias="model_output_name", default=None)
+
+    x_model_output_path: Optional[str] = FieldInfo(alias="model_output_path", default=None)
+
+    n_checkpoints: Optional[int] = None
+
+    n_epochs: Optional[int] = None
+
+    n_evals: Optional[int] = None
+
+    param_count: Optional[int] = None
+
+    queue_depth: Optional[int] = None
+
+    token_count: Optional[int] = None
+
+    total_price: Optional[int] = None
+
+    train_on_inputs: Union[bool, Literal["auto"], None] = None
+
+    training_file: Optional[str] = None
+
+    training_method: Optional[TrainingMethod] = None
+
+    training_type: Optional[TrainingType] = None
+
+    trainingfile_numlines: Optional[int] = None
+
+    trainingfile_size: Optional[int] = None
+
+    updated_at: Optional[str] = None
+
+    validation_file: Optional[str] = None
+
+    wandb_project_name: Optional[str] = None
+
+    wandb_url: Optional[str] = None
+
+    warmup_ratio: Optional[float] = None
+
+    weight_decay: Optional[float] = None

together/types/hardware_list_params.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["HardwareListParams"]
+
+
+class HardwareListParams(TypedDict, total=False):
+    model: str
+    """Filter hardware configurations by model compatibility.
+
+    When provided, the response includes availability status for each compatible
+    configuration.
+    """

together/types/hardware_list_response.py

@@ -0,0 +1,58 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["HardwareListResponse", "Data", "DataPricing", "DataSpecs", "DataAvailability"]
+
+
+class DataPricing(BaseModel):
+    cents_per_minute: float
+    """Cost per minute of endpoint uptime in cents"""
+
+
+class DataSpecs(BaseModel):
+    gpu_count: int
+    """Number of GPUs in this configuration"""
+
+    gpu_link: str
+    """The GPU interconnect technology"""
+
+    gpu_memory: float
+    """Amount of GPU memory in GB"""
+
+    gpu_type: str
+    """The type/model of GPU"""
+
+
+class DataAvailability(BaseModel):
+    status: Literal["available", "unavailable", "insufficient"]
+    """The availability status of the hardware configuration"""
+
+
+class Data(BaseModel):
+    id: str
+    """Unique identifier for the hardware configuration"""
+
+    object: Literal["hardware"]
+
+    pricing: DataPricing
+    """Pricing details for using an endpoint"""
+
+    specs: DataSpecs
+    """Detailed specifications of a hardware configuration"""
+
+    updated_at: datetime
+    """Timestamp of when the hardware status was last updated"""
+
+    availability: Optional[DataAvailability] = None
+    """Indicates the current availability status of a hardware configuration"""
+
+
+class HardwareListResponse(BaseModel):
+    data: List[Data]
+
+    object: Literal["list"]

together/types/image_data_b64.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ImageDataB64"]
+
+
+class ImageDataB64(BaseModel):
+    b64_json: str
+
+    index: int
+
+    type: Literal["b64_json"]

together/types/image_data_url.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ImageDataURL"]
+
+
+class ImageDataURL(BaseModel):
+    index: int
+
+    type: Literal["url"]
+
+    url: str

together/types/image_file.py

@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from .._utils import PropertyInfo
+from .._models import BaseModel
+from .image_data_b64 import ImageDataB64
+from .image_data_url import ImageDataURL
+
+__all__ = ["ImageFile", "Data"]
+
+Data: TypeAlias = Annotated[Union[ImageDataB64, ImageDataURL], PropertyInfo(discriminator="type")]
+
+
+class ImageFile(BaseModel):
+    id: str
+
+    data: List[Data]
+
+    model: str
+
+    object: Literal["list"]

together/types/image_generate_params.py

@@ -0,0 +1,85 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Iterable
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ImageGenerateParams", "ImageLora"]
+
+
+class ImageGenerateParams(TypedDict, total=False):
+    model: Required[
+        Union[
+            Literal[
+                "black-forest-labs/FLUX.1-schnell-Free",
+                "black-forest-labs/FLUX.1-schnell",
+                "black-forest-labs/FLUX.1.1-pro",
+            ],
+            str,
+        ]
+    ]
+    """The model to use for image generation.
+
+    [See all of Together AI's image models](https://docs.together.ai/docs/serverless-models#image-models)
+    """
+
+    prompt: Required[str]
+    """A description of the desired images. Maximum length varies by model."""
+
+    disable_safety_checker: bool
+    """If true, disables the safety checker for image generation."""
+
+    guidance_scale: float
+    """Adjusts the alignment of the generated image with the input prompt.
+
+    Higher values (e.g., 8-10) make the output more faithful to the prompt, while
+    lower values (e.g., 1-5) encourage more creative freedom.
+    """
+
+    height: int
+    """Height of the image to generate in number of pixels."""
+
+    image_loras: Iterable[ImageLora]
+    """
+    An array of objects that define LoRAs (Low-Rank Adaptations) to influence the
+    generated image.
+    """
+
+    image_url: str
+    """URL of an image to use for image models that support it."""
+
+    n: int
+    """Number of image results to generate."""
+
+    negative_prompt: str
+    """The prompt or prompts not to guide the image generation."""
+
+    output_format: Literal["jpeg", "png"]
+    """The format of the image response.
+
+    Can be either be `jpeg` or `png`. Defaults to `jpeg`.
+    """
+
+    response_format: Literal["base64", "url"]
+    """Format of the image response. Can be either a base64 string or a URL."""
+
+    seed: int
+    """Seed used for generation. Can be used to reproduce image generations."""
+
+    steps: int
+    """Number of generation steps."""
+
+    width: int
+    """Width of the image to generate in number of pixels."""
+
+
+class ImageLora(TypedDict, total=False):
+    path: Required[str]
+    """The URL of the LoRA to apply (e.g.
+
+    https://huggingface.co/strangerzonehf/Flux-Midjourney-Mix2-LoRA).
+    """
+
+    scale: Required[float]
+    """The strength of the LoRA's influence. Most LoRA's recommend a value of 1."""