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

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."""

together/types/job_list_response.py

@@ -0,0 +1,47 @@
+# 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 pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["JobListResponse", "Data", "DataArgs", "DataStatusUpdate"]
+
+
+class DataArgs(BaseModel):
+    description: Optional[str] = None
+
+    x_model_name: Optional[str] = FieldInfo(alias="modelName", default=None)
+
+    x_model_source: Optional[str] = FieldInfo(alias="modelSource", default=None)
+
+
+class DataStatusUpdate(BaseModel):
+    message: str
+
+    status: str
+
+    timestamp: datetime
+
+
+class Data(BaseModel):
+    args: DataArgs
+
+    created_at: datetime
+
+    job_id: str
+
+    status: Literal["Queued", "Running", "Complete", "Failed"]
+
+    status_updates: List[DataStatusUpdate]
+
+    type: str
+
+    updated_at: datetime
+
+
+class JobListResponse(BaseModel):
+    data: List[Data]

together/types/job_retrieve_response.py

@@ -0,0 +1,43 @@
+# 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 pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["JobRetrieveResponse", "Args", "StatusUpdate"]
+
+
+class Args(BaseModel):
+    description: Optional[str] = None
+
+    x_model_name: Optional[str] = FieldInfo(alias="modelName", default=None)
+
+    x_model_source: Optional[str] = FieldInfo(alias="modelSource", default=None)
+
+
+class StatusUpdate(BaseModel):
+    message: str
+
+    status: str
+
+    timestamp: datetime
+
+
+class JobRetrieveResponse(BaseModel):
+    args: Args
+
+    created_at: datetime
+
+    job_id: str
+
+    status: Literal["Queued", "Running", "Complete", "Failed"]
+
+    status_updates: List[StatusUpdate]
+
+    type: str
+
+    updated_at: datetime

together/types/log_probs.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from .._models import BaseModel
+
+__all__ = ["LogProbs"]
+
+
+class LogProbs(BaseModel):
+    token_ids: Optional[List[float]] = None
+    """List of token IDs corresponding to the logprobs"""
+
+    token_logprobs: Optional[List[float]] = None
+    """List of token log probabilities"""
+
+    tokens: Optional[List[str]] = None
+    """List of token strings"""

together/types/model_list_response.py

@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+from typing_extensions import TypeAlias
+
+from .model_object import ModelObject
+
+__all__ = ["ModelListResponse"]
+
+ModelListResponse: TypeAlias = List[ModelObject]

together/types/model_object.py

@@ -0,0 +1,42 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ModelObject", "Pricing"]
+
+
+class Pricing(BaseModel):
+    base: float
+
+    finetune: float
+
+    hourly: float
+
+    input: float
+
+    output: float
+
+
+class ModelObject(BaseModel):
+    id: str
+
+    created: int
+
+    object: str
+
+    type: Literal["chat", "language", "code", "image", "embedding", "moderation", "rerank"]
+
+    context_length: Optional[int] = None
+
+    display_name: Optional[str] = None
+
+    license: Optional[str] = None
+
+    link: Optional[str] = None
+
+    organization: Optional[str] = None
+
+    pricing: Optional[Pricing] = None

together/types/model_upload_params.py

@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ModelUploadParams"]
+
+
+class ModelUploadParams(TypedDict, total=False):
+    model_name: Required[str]
+    """The name to give to your uploaded model"""
+
+    model_source: Required[str]
+    """The source location of the model (Hugging Face repo or S3 path)"""
+
+    base_model: str
+    """
+    The base model to use for an adapter if setting it to run against a serverless
+    pool. Only used for model_type `adapter`.
+    """
+
+    description: str
+    """A description of your model"""
+
+    hf_token: str
+    """Hugging Face token (if uploading from Hugging Face)"""
+
+    lora_model: str
+    """
+    The lora pool to use for an adapter if setting it to run against, say, a
+    dedicated pool. Only used for model_type `adapter`.
+    """
+
+    model_type: Literal["model", "adapter"]
+    """Whether the model is a full model or an adapter"""

together/types/model_upload_response.py

@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["ModelUploadResponse", "Data"]
+
+
+class Data(BaseModel):
+    job_id: str
+
+    x_model_id: str = FieldInfo(alias="model_id")
+
+    x_model_name: str = FieldInfo(alias="model_name")
+
+    x_model_source: str = FieldInfo(alias="model_source")
+
+
+class ModelUploadResponse(BaseModel):
+    data: Data
+
+    message: str

together/types/rerank_create_params.py

@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Iterable
+from typing_extensions import Literal, Required, TypedDict
+
+from .._types import SequenceNotStr
+
+__all__ = ["RerankCreateParams"]
+
+
+class RerankCreateParams(TypedDict, total=False):
+    documents: Required[Union[Iterable[Dict[str, object]], SequenceNotStr[str]]]
+    """List of documents, which can be either strings or objects."""
+
+    model: Required[Union[Literal["Salesforce/Llama-Rank-v1"], str]]
+    """The model to be used for the rerank request.
+
+    [See all of Together AI's rerank models](https://docs.together.ai/docs/serverless-models#rerank-models)
+    """
+
+    query: Required[str]
+    """The search query to be used for ranking."""
+
+    rank_fields: SequenceNotStr[str]
+    """List of keys in the JSON Object document to rank by.
+
+    Defaults to use all supplied keys for ranking.
+    """
+
+    return_documents: bool
+    """Whether to return supplied documents with the response."""
+
+    top_n: int
+    """The number of top results to return."""

together/types/rerank_create_response.py

@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+from .chat.chat_completion_usage import ChatCompletionUsage
+
+__all__ = ["RerankCreateResponse", "Result", "ResultDocument"]
+
+
+class ResultDocument(BaseModel):
+    text: Optional[str] = None
+
+
+class Result(BaseModel):
+    document: ResultDocument
+
+    index: int
+
+    relevance_score: float
+
+
+class RerankCreateResponse(BaseModel):
+    model: str
+    """The model to be used for the rerank request."""
+
+    object: Literal["rerank"]
+    """Object type"""
+
+    results: List[Result]
+
+    id: Optional[str] = None
+    """Request ID"""
+
+    usage: Optional[ChatCompletionUsage] = None