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

together/types/finetune.py

@@ -1,465 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import Any, List, Literal
-
-from pydantic import Field, StrictBool, field_validator
-
-from together.types.abstract import BaseModel
-from together.types.common import ObjectType
-
-
-class FinetuneJobStatus(str, Enum):
-    """
-    Possible fine-tune job status
-    """
-
-    STATUS_PENDING = "pending"
-    STATUS_QUEUED = "queued"
-    STATUS_RUNNING = "running"
-    STATUS_COMPRESSING = "compressing"
-    STATUS_UPLOADING = "uploading"
-    STATUS_CANCEL_REQUESTED = "cancel_requested"
-    STATUS_CANCELLED = "cancelled"
-    STATUS_ERROR = "error"
-    STATUS_USER_ERROR = "user_error"
-    STATUS_COMPLETED = "completed"
-
-
-COMPLETED_STATUSES = [
-    FinetuneJobStatus.STATUS_ERROR,
-    FinetuneJobStatus.STATUS_USER_ERROR,
-    FinetuneJobStatus.STATUS_COMPLETED,
-    FinetuneJobStatus.STATUS_CANCELLED,
-]
-
-
-class FinetuneEventLevels(str, Enum):
-    """
-    Fine-tune job event status levels
-    """
-
-    NULL = ""
-    INFO = "Info"
-    WARNING = "Warning"
-    ERROR = "Error"
-    LEGACY_INFO = "info"
-    LEGACY_IWARNING = "warning"
-    LEGACY_IERROR = "error"
-
-
-class FinetuneEventType(str, Enum):
-    """
-    Fine-tune job event types
-    """
-
-    JOB_PENDING = "JOB_PENDING"
-    JOB_START = "JOB_START"
-    JOB_STOPPED = "JOB_STOPPED"
-    MODEL_DOWNLOADING = "MODEL_DOWNLOADING"
-    MODEL_DOWNLOAD_COMPLETE = "MODEL_DOWNLOAD_COMPLETE"
-    TRAINING_DATA_DOWNLOADING = "TRAINING_DATA_DOWNLOADING"
-    TRAINING_DATA_DOWNLOAD_COMPLETE = "TRAINING_DATA_DOWNLOAD_COMPLETE"
-    VALIDATION_DATA_DOWNLOADING = "VALIDATION_DATA_DOWNLOADING"
-    VALIDATION_DATA_DOWNLOAD_COMPLETE = "VALIDATION_DATA_DOWNLOAD_COMPLETE"
-    WANDB_INIT = "WANDB_INIT"
-    TRAINING_START = "TRAINING_START"
-    CHECKPOINT_SAVE = "CHECKPOINT_SAVE"
-    BILLING_LIMIT = "BILLING_LIMIT"
-    EPOCH_COMPLETE = "EPOCH_COMPLETE"
-    EVAL_COMPLETE = "EVAL_COMPLETE"
-    TRAINING_COMPLETE = "TRAINING_COMPLETE"
-    MODEL_COMPRESSING = "COMPRESSING_MODEL"
-    MODEL_COMPRESSION_COMPLETE = "MODEL_COMPRESSION_COMPLETE"
-    MODEL_UPLOADING = "MODEL_UPLOADING"
-    MODEL_UPLOAD_COMPLETE = "MODEL_UPLOAD_COMPLETE"
-    MODEL_UPLOADING_TO_HF = "MODEL_UPLOADING_TO_HF"
-    MODEL_UPLOAD_TO_HF_COMPLETE = "MODEL_UPLOAD_TO_HF_COMPLETE"
-    JOB_COMPLETE = "JOB_COMPLETE"
-    JOB_ERROR = "JOB_ERROR"
-    JOB_USER_ERROR = "JOB_USER_ERROR"
-    CANCEL_REQUESTED = "CANCEL_REQUESTED"
-    JOB_RESTARTED = "JOB_RESTARTED"
-    REFUND = "REFUND"
-    WARNING = "WARNING"
-
-
-class DownloadCheckpointType(Enum):
-    DEFAULT = "default"
-    MERGED = "merged"
-    ADAPTER = "adapter"
-
-
-class FinetuneEvent(BaseModel):
-    """
-    Fine-tune event type
-    """
-
-    # object type
-    object: Literal[ObjectType.FinetuneEvent]
-    # created at datetime stamp
-    created_at: str | None = None
-    # event log level
-    level: FinetuneEventLevels | None = None
-    # event message string
-    message: str | None = None
-    # event type
-    type: FinetuneEventType | None = None
-    # optional: model parameter count
-    param_count: int | None = None
-    # optional: dataset token count
-    token_count: int | None = None
-    # optional: weights & biases url
-    wandb_url: str | None = None
-    # event hash
-    hash: str | None = None
-
-
-class TrainingType(BaseModel):
-    """
-    Abstract training type
-    """
-
-    type: str
-
-
-class FullTrainingType(TrainingType):
-    """
-    Training type for full fine-tuning
-    """
-
-    type: str = "Full"
-
-
-class LoRATrainingType(TrainingType):
-    """
-    Training type for LoRA adapters training
-    """
-
-    lora_r: int
-    lora_alpha: int
-    lora_dropout: float = 0.0
-    lora_trainable_modules: str = "all-linear"
-    type: str = "Lora"
-
-
-class TrainingMethod(BaseModel):
-    """
-    Training method type
-    """
-
-    method: str
-
-
-class TrainingMethodSFT(TrainingMethod):
-    """
-    Training method type for SFT training
-    """
-
-    method: Literal["sft"] = "sft"
-    train_on_inputs: StrictBool | Literal["auto"] = "auto"
-
-
-class TrainingMethodDPO(TrainingMethod):
-    """
-    Training method type for DPO training
-    """
-
-    method: Literal["dpo"] = "dpo"
-    dpo_beta: float | None = None
-    dpo_normalize_logratios_by_length: bool = False
-    dpo_reference_free: bool = False
-    rpo_alpha: float | None = None
-    simpo_gamma: float | None = None
-
-
-class FinetuneMultimodalParams(BaseModel):
-    """
-    Multimodal parameters
-    """
-
-    train_vision: bool = False
-
-
-class FinetuneProgress(BaseModel):
-    """
-    Fine-tune job progress
-    """
-
-    estimate_available: bool = False
-    seconds_remaining: float = 0
-
-
-class FinetuneRequest(BaseModel):
-    """
-    Fine-tune request type
-    """
-
-    # training file ID
-    training_file: str
-    # validation file id
-    validation_file: str | None = None
-    # base model string
-    model: str | None = None
-    # number of epochs to train for
-    n_epochs: int
-    # training learning rate
-    learning_rate: float
-    # learning rate scheduler type and args
-    lr_scheduler: LinearLRScheduler | CosineLRScheduler | None = None
-    # learning rate warmup ratio
-    warmup_ratio: float
-    # max gradient norm
-    max_grad_norm: float
-    # weight decay
-    weight_decay: float
-    # number of checkpoints to save
-    n_checkpoints: int | None = None
-    # number of evaluation loops to run
-    n_evals: int | None = None
-    # training batch size
-    batch_size: int | Literal["max"] | None = None
-    # up to 40 character suffix for output model name
-    suffix: str | None = None
-    # weights & biases api key
-    wandb_key: str | None = None
-    # weights & biases base url
-    wandb_base_url: str | None = None
-    # wandb project name
-    wandb_project_name: str | None = None
-    # wandb run name
-    wandb_name: str | None = None
-    # training type
-    training_type: FullTrainingType | LoRATrainingType | None = None
-    # training method
-    training_method: TrainingMethodSFT | TrainingMethodDPO = Field(
-        default_factory=TrainingMethodSFT
-    )
-    # from step
-    from_checkpoint: str | None = None
-    # multimodal parameters
-    multimodal_params: FinetuneMultimodalParams | None = None
-    # hf related fields
-    hf_api_token: str | None = None
-    hf_output_repo_name: str | None = None
-
-
-class FinetuneResponse(BaseModel):
-    """
-    Fine-tune API response type
-    """
-
-    # job ID
-    id: str | None = None
-    # training file id
-    training_file: str | None = None
-    # validation file id
-    validation_file: str | None = None
-    # base model name
-    model: str | None = None
-    # output model name
-    output_name: str | None = Field(None, alias="model_output_name")
-    # adapter output name
-    adapter_output_name: str | None = None
-    # number of epochs
-    n_epochs: int | None = None
-    # number of checkpoints to save
-    n_checkpoints: int | None = None
-    # number of evaluation loops
-    n_evals: int | None = None
-    # training batch size
-    batch_size: int | None = None
-    # training learning rate
-    learning_rate: float | None = None
-    # learning rate scheduler type and args
-    lr_scheduler: LinearLRScheduler | CosineLRScheduler | EmptyLRScheduler | None = None
-    # learning rate warmup ratio
-    warmup_ratio: float | None = None
-    # max gradient norm
-    max_grad_norm: float | None = None
-    # weight decay
-    weight_decay: float | None = None
-    # number of steps between evals
-    eval_steps: int | None = None
-    # training type
-    training_type: TrainingType | None = None
-    # created/updated datetime stamps
-    created_at: str | None = None
-    updated_at: str | None = None
-    started_at: str | None = None
-    # job status
-    status: FinetuneJobStatus | None = None
-    # job id
-    job_id: str | None = None
-    # list of fine-tune events
-    events: List[FinetuneEvent] | None = None
-    # dataset token count
-    token_count: int | None = None
-    # model parameter count
-    param_count: int | None = None
-    # fine-tune job price
-    total_price: int | None = None
-    # total number of training steps
-    total_steps: int | None = None
-    # number of steps completed (incrementing counter)
-    steps_completed: int | None = None
-    # number of epochs completed (incrementing counter)
-    epochs_completed: int | None = None
-    # number of evaluation loops completed (incrementing counter)
-    evals_completed: int | None = None
-    # place in job queue (decrementing counter)
-    queue_depth: int | None = None
-    # weights & biases base url
-    wandb_base_url: str | None = None
-    # wandb project name
-    wandb_project_name: str | None = None
-    # wandb run name
-    wandb_name: str | None = None
-    # weights & biases job url
-    wandb_url: str | None = None
-    # training file metadata
-    training_file_num_lines: int | None = Field(None, alias="TrainingFileNumLines")
-    training_file_size: int | None = Field(None, alias="TrainingFileSize")
-    train_on_inputs: StrictBool | Literal["auto"] | None = "auto"
-    from_checkpoint: str | None = None
-    # multimodal parameters
-    multimodal_params: FinetuneMultimodalParams | None = None
-
-    progress: FinetuneProgress | None = None
-
-    @field_validator("training_type")
-    @classmethod
-    def validate_training_type(cls, v: TrainingType) -> TrainingType:
-        if v.type == "Full" or v.type == "":
-            return FullTrainingType(**v.model_dump())
-        elif v.type == "Lora":
-            return LoRATrainingType(**v.model_dump())
-        else:
-            raise ValueError("Unknown training type")
-
-
-class FinetunePriceEstimationRequest(BaseModel):
-    """
-    Fine-tune price estimation request type
-    """
-
-    training_file: str
-    validation_file: str | None = None
-    model: str
-    n_epochs: int
-    n_evals: int
-    training_type: LoRATrainingType | FullTrainingType
-    training_method: TrainingMethodSFT | TrainingMethodDPO
-
-
-class FinetunePriceEstimationResponse(BaseModel):
-    """
-    Fine-tune price estimation response type
-    """
-
-    estimated_total_price: float
-    user_limit: float
-    estimated_train_token_count: int
-    estimated_eval_token_count: int
-    allowed_to_proceed: bool
-
-
-class FinetuneList(BaseModel):
-    # object type
-    object: Literal["list"] | None = None
-    # list of fine-tune job objects
-    data: List[FinetuneResponse] | None = None
-
-
-class FinetuneListEvents(BaseModel):
-    # object type
-    object: Literal["list"] | None = None
-    # list of fine-tune events
-    data: List[FinetuneEvent] | None = None
-
-
-class FinetuneDeleteResponse(BaseModel):
-    # delete message
-    message: str
-
-
-class FinetuneDownloadResult(BaseModel):
-    # object type
-    object: Literal["local"] | None = None
-    # fine-tune job id
-    id: str | None = None
-    # checkpoint step number
-    checkpoint_step: int | None = None
-    # local path filename
-    filename: str | None = None
-    # size in bytes
-    size: int | None = None
-
-
-class FinetuneFullTrainingLimits(BaseModel):
-    max_batch_size: int
-    max_batch_size_dpo: int = -1
-    min_batch_size: int
-
-    def __init__(self, **data: Any) -> None:
-        super().__init__(**data)
-        if self.max_batch_size_dpo == -1:
-            half_max = self.max_batch_size // 2
-            rounded_half_max = (half_max // 8) * 8
-            self.max_batch_size_dpo = max(self.min_batch_size, rounded_half_max)
-
-
-class FinetuneLoraTrainingLimits(FinetuneFullTrainingLimits):
-    max_rank: int
-    target_modules: List[str]
-
-
-class FinetuneTrainingLimits(BaseModel):
-    max_num_epochs: int
-    max_learning_rate: float
-    min_learning_rate: float
-    full_training: FinetuneFullTrainingLimits | None = None
-    lora_training: FinetuneLoraTrainingLimits | None = None
-    supports_vision: bool = False
-
-
-class LinearLRSchedulerArgs(BaseModel):
-    min_lr_ratio: float | None = 0.0
-
-
-class CosineLRSchedulerArgs(BaseModel):
-    min_lr_ratio: float | None = 0.0
-    num_cycles: float | None = 0.5
-
-
-class FinetuneLRScheduler(BaseModel):
-    lr_scheduler_type: str
-
-
-class LinearLRScheduler(FinetuneLRScheduler):
-    lr_scheduler_type: Literal["linear"] = "linear"
-    lr_scheduler_args: LinearLRSchedulerArgs | None = None
-
-
-class CosineLRScheduler(FinetuneLRScheduler):
-    lr_scheduler_type: Literal["cosine"] = "cosine"
-    lr_scheduler_args: CosineLRSchedulerArgs | None = None
-
-
-# placeholder for old fine-tuning jobs with no lr_scheduler_type specified
-class EmptyLRScheduler(FinetuneLRScheduler):
-    lr_scheduler_type: Literal[""]
-    lr_scheduler_args: None = None
-
-
-class FinetuneCheckpoint(BaseModel):
-    """
-    Fine-tuning checkpoint information
-    """
-
-    # checkpoint type (e.g. "Intermediate", "Final", "Final Merged", "Final Adapter")
-    type: str
-    # timestamp when the checkpoint was created
-    timestamp: str
-    # checkpoint name/identifier
-    name: str

together/types/images.py

@@ -1,42 +0,0 @@
-from __future__ import annotations
-
-from typing import List, Literal
-
-from together.types.abstract import BaseModel
-
-
-class ImageRequest(BaseModel):
-    # input or list of inputs
-    prompt: str
-    # model to query
-    model: str
-    # seed
-    seed: int | None = None
-    # number of results to return
-    n: int | None = 1
-    # pixel height
-    height: int | None = 1024
-    # pixel width
-    width: int | None = 1024
-    # negative prompt
-    negative_prompt: str | None = None
-
-
-class ImageChoicesData(BaseModel):
-    # response index
-    index: int
-    # base64 image response
-    b64_json: str | None = None
-    # URL hosting image
-    url: str | None = None
-
-
-class ImageResponse(BaseModel):
-    # job id
-    id: str | None = None
-    # query model
-    model: str | None = None
-    # object type
-    object: Literal["list"] | None = None
-    # list of embedding choices
-    data: List[ImageChoicesData] | None = None

together/types/models.py

@@ -1,96 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import Any, Dict, Literal, Optional
-
-from together.types.abstract import BaseModel
-from together.types.common import ObjectType
-
-
-class ModelType(str, Enum):
-    CHAT = "chat"
-    LANGUAGE = "language"
-    CODE = "code"
-    IMAGE = "image"
-    EMBEDDING = "embedding"
-    MODERATION = "moderation"
-    RERANK = "rerank"
-    AUDIO = "audio"
-    TRANSCRIBE = "transcribe"
-    VIDEO = "video"
-
-
-class PricingObject(BaseModel):
-    input: float | None = None
-    output: float | None = None
-    hourly: float | None = None
-    base: float | None = None
-    finetune: float | None = None
-
-
-class ModelObject(BaseModel):
-    # model id
-    id: str
-    # object type
-    object: Literal[ObjectType.Model]
-    created: int | None = None
-    # model type
-    type: ModelType | None = None
-    # pretty name
-    display_name: str | None = None
-    # model creator organization
-    organization: str | None = None
-    # link to model resource
-    link: str | None = None
-    license: str | None = None
-    context_length: int | None = None
-    pricing: PricingObject
-
-
-class ModelUploadRequest(BaseModel):
-    model_name: str
-    model_source: str
-    model_type: Literal["model", "adapter"] = "model"
-    hf_token: Optional[str] = None
-    description: Optional[str] = None
-    base_model: Optional[str] = None
-    lora_model: Optional[str] = None
-
-
-class ModelUploadResponse(BaseModel):
-    job_id: Optional[str] = None
-    model_name: Optional[str] = None
-    model_id: Optional[str] = None
-    model_source: Optional[str] = None
-    message: str
-
-    @classmethod
-    def from_api_response(cls, response_data: Dict[str, Any]) -> "ModelUploadResponse":
-        """Create ModelUploadResponse from API response, handling both flat and nested structures"""
-        # Start with the base response
-        result: Dict[str, Any] = {"message": response_data.get("message", "")}
-
-        # Check if we have nested data
-        if "data" in response_data and response_data["data"] is not None:
-            # Use nested data values
-            nested_data = response_data["data"]
-            result.update(
-                {
-                    "job_id": nested_data.get("job_id"),
-                    "model_name": nested_data.get("model_name"),
-                    "model_id": nested_data.get("model_id"),
-                    "model_source": nested_data.get("model_source"),
-                }
-            )
-        else:
-            # Use top-level values
-            result.update(
-                {
-                    "job_id": response_data.get("job_id"),
-                    "model_name": response_data.get("model_name"),
-                    "model_id": response_data.get("model_id"),
-                    "model_source": response_data.get("model_source"),
-                }
-            )
-
-        return cls(**result)

together/types/rerank.py

@@ -1,43 +0,0 @@
-from __future__ import annotations
-
-from typing import List, Literal, Dict, Any
-
-from together.types.abstract import BaseModel
-from together.types.common import UsageData
-
-
-class RerankRequest(BaseModel):
-    # model to query
-    model: str
-    # input or list of inputs
-    query: str
-    # list of documents
-    documents: List[str] | List[Dict[str, Any]]
-    # return top_n results
-    top_n: int | None = None
-    # boolean to return documents
-    return_documents: bool = False
-    # field selector for documents
-    rank_fields: List[str] | None = None
-
-
-class RerankChoicesData(BaseModel):
-    # response index
-    index: int
-    # object type
-    relevance_score: float
-    # rerank response
-    document: Dict[str, Any] | None = None
-
-
-class RerankResponse(BaseModel):
-    # job id
-    id: str | None = None
-    # object type
-    object: Literal["rerank"] | None = None
-    # query model
-    model: str | None = None
-    # list of reranked results
-    results: List[RerankChoicesData] | None = None
-    # usage stats
-    usage: UsageData | None = None

together/types/videos.py

@@ -1,69 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict, List, Literal, Optional
-
-from together.types.abstract import BaseModel
-
-
-class CreateVideoBody(BaseModel):
-    """Request model for video creation"""
-
-    # Required parameters
-    model: str
-
-    # Optional dimension parameters
-    prompt: str | None = None
-    height: int | None = None
-    width: int | None = None
-
-    # Optional generation parameters
-    seconds: str | None = None  # Min 1 max 10
-    fps: int | None = None  # Frames per second, min 15 max 60, default 24
-    steps: int | None = None  # Denoising steps, min 10 max 50, default 20
-    seed: int | None = None
-    guidance_scale: float | None = None  # Default 8, recommended 6.0-10.0
-    output_format: Literal["MP4", "WEBM"] | None = (
-        None  # "MP4" or "WEBM", default "MP4"
-    )
-    output_quality: int | None = None  # Compression quality, default 20
-    negative_prompt: str | None = None
-
-    # Advanced parameters
-    frame_images: List[Dict[str, Any]] | None = None  # Array of keyframe images
-    reference_images: List[str] | None = None  # Array of reference images
-
-
-class VideoOutputs(BaseModel):
-    """Artifacts generated from video creation job"""
-
-    cost: float
-    video_url: str
-
-
-class Error(BaseModel):
-    """Error information about the video job"""
-
-    code: str | None = None
-    message: str
-
-
-class CreateVideoResponse(BaseModel):
-    """Response from video generation request"""
-
-    id: str
-
-
-class VideoJob(BaseModel):
-    """Structured information describing a generated video job."""
-
-    id: str
-    model: str
-    object: Literal["video"]
-    status: Literal["queued", "in_progress", "completed", "failed", "cancelled"]
-    seconds: str
-    size: str
-    created_at: int
-
-    error: Error | None = None
-    outputs: VideoOutputs | None = None
-    completed_at: int | None = None