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

together/types/finetune.py

@@ -1,265 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import List, Literal
-
-from pydantic import Field, validator, 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"
-
-
-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"
-    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 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
-    # number of epochs to train for
-    n_epochs: int
-    # training learning rate
-    learning_rate: 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 | None = None
-    # up to 40 character suffix for output model name
-    suffix: str | None = None
-    # weights & biases api key
-    wandb_key: str | None = None
-    training_type: FullTrainingType | LoRATrainingType | 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
-    # 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
-    # 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 project name
-    wandb_project_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")
-
-    @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 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 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

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
-    # num generation steps
-    steps: int | None = 20
-    # 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
-
-
-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,44 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import Literal
-
-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"
-
-
-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

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/utils/api_helpers.py

@@ -1,84 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-import platform
-from typing import TYPE_CHECKING, Any, Dict
-
-
-if TYPE_CHECKING:
-    from _typeshed import SupportsKeysAndGetItem
-
-import together
-from together import error
-from together.utils._log import _console_log_level
-
-
-def get_headers(
-    method: str | None = None,
-    api_key: str | None = None,
-    extra: "SupportsKeysAndGetItem[str, Any] | None" = None,
-) -> Dict[str, str]:
-    """
-    Generates request headers with API key, metadata, and supplied headers
-
-    Args:
-        method (str, optional): HTTP request type (POST, GET, etc.)
-            Defaults to None.
-        api_key (str, optional): API key to add as an Authorization header.
-            Defaults to None.
-        extra (SupportsKeysAndGetItem[str, Any], optional): Additional headers to add to request.
-            Defaults to None.
-
-    Returns:
-        headers (Dict[str, str]): Compiled headers from data
-    """
-
-    user_agent = "Together/v1 PythonBindings/%s" % (together.version,)
-
-    uname_without_node = " ".join(
-        v for k, v in platform.uname()._asdict().items() if k != "node"
-    )
-    ua = {
-        "bindings_version": together.version,
-        "httplib": "requests",
-        "lang": "python",
-        "lang_version": platform.python_version(),
-        "platform": platform.platform(),
-        "publisher": "together",
-        "uname": uname_without_node,
-    }
-
-    headers: Dict[str, Any] = {
-        "X-Together-Client-User-Agent": json.dumps(ua),
-        "Authorization": f"Bearer {default_api_key(api_key)}",
-        "User-Agent": user_agent,
-    }
-
-    if _console_log_level():
-        headers["Together-Debug"] = _console_log_level()
-    if extra:
-        headers.update(extra)
-
-    return headers
-
-
-def default_api_key(api_key: str | None = None) -> str | None:
-    """
-    API key fallback logic from input argument and environment variable
-
-    Args:
-        api_key (str, optional): Supplied API key. This argument takes priority over env var
-
-    Returns:
-        together_api_key (str): Returns API key from supplied input or env var
-
-    Raises:
-        together.error.AuthenticationError: if API key not found
-    """
-    if api_key:
-        return api_key
-    if os.environ.get("TOGETHER_API_KEY"):
-        return os.environ.get("TOGETHER_API_KEY")
-
-    raise error.AuthenticationError(together.constants.MISSING_API_KEY_MESSAGE)

together/utils/files.py

@@ -1,204 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-from pathlib import Path
-from traceback import format_exc
-from typing import Any, Dict
-
-from pyarrow import ArrowInvalid, parquet
-
-from together.constants import (
-    MAX_FILE_SIZE_GB,
-    MIN_SAMPLES,
-    NUM_BYTES_IN_GB,
-    PARQUET_EXPECTED_COLUMNS,
-)
-
-
-def check_file(
-    file: Path | str,
-) -> Dict[str, Any]:
-    if not isinstance(file, Path):
-        file = Path(file)
-
-    report_dict = {
-        "is_check_passed": True,
-        "message": "Checks passed",
-        "found": None,
-        "file_size": None,
-        "utf8": None,
-        "line_type": None,
-        "text_field": None,
-        "key_value": None,
-        "min_samples": None,
-        "num_samples": None,
-        "load_json": None,
-    }
-
-    if not file.is_file():
-        report_dict["found"] = False
-        report_dict["is_check_passed"] = False
-        return report_dict
-    else:
-        report_dict["found"] = True
-
-    file_size = os.stat(file.as_posix()).st_size
-
-    if file_size > MAX_FILE_SIZE_GB * NUM_BYTES_IN_GB:
-        report_dict["message"] = (
-            f"Maximum supported file size is {MAX_FILE_SIZE_GB} GB. Found file with size of {round(file_size / NUM_BYTES_IN_GB ,3)} GB."
-        )
-        report_dict["is_check_passed"] = False
-    elif file_size == 0:
-        report_dict["message"] = "File is empty"
-        report_dict["file_size"] = 0
-        report_dict["is_check_passed"] = False
-        return report_dict
-    else:
-        report_dict["file_size"] = file_size
-
-    if file.suffix == ".jsonl":
-        report_dict["filetype"] = "jsonl"
-        data_report_dict = _check_jsonl(file)
-    elif file.suffix == ".parquet":
-        report_dict["filetype"] = "parquet"
-        data_report_dict = _check_parquet(file)
-    else:
-        report_dict["filetype"] = (
-            f"Unknown extension of file {file}. "
-            "Only files with extensions .jsonl and .parquet are supported."
-        )
-        report_dict["is_check_passed"] = False
-
-    report_dict.update(data_report_dict)
-    return report_dict
-
-
-def _check_jsonl(file: Path) -> Dict[str, Any]:
-    report_dict: Dict[str, Any] = {}
-    # Check that the file is UTF-8 encoded. If not report where the error occurs.
-    try:
-        with file.open(encoding="utf-8") as f:
-            f.read()
-        report_dict["utf8"] = True
-    except UnicodeDecodeError as e:
-        report_dict["utf8"] = False
-        report_dict["message"] = f"File is not UTF-8 encoded. Error raised: {e}."
-        report_dict["is_check_passed"] = False
-        return report_dict
-
-    with file.open() as f:
-        # idx must be instantiated so decode errors (e.g. file is a tar) or empty files are caught
-        idx = -1
-        try:
-            for idx, line in enumerate(f):
-                json_line = json.loads(line)  # each line in jsonlines should be a json
-
-                if not isinstance(json_line, dict):
-                    report_dict["line_type"] = False
-                    report_dict["message"] = (
-                        f"Error parsing file. Invalid format on line {idx + 1} of the input file. "
-                        'Example of valid json: {"text": "my sample string"}. '
-                    )
-
-                    report_dict["is_check_passed"] = False
-
-                if "text" not in json_line.keys():
-                    report_dict["text_field"] = False
-                    report_dict["message"] = (
-                        f"Missing 'text' field was found on line {idx + 1} of the the input file. "
-                        "Expected format: {'text': 'my sample string'}. "
-                    )
-                    report_dict["is_check_passed"] = False
-                else:
-                    # check to make sure the value of the "text" key is a string
-                    if not isinstance(json_line["text"], str):
-                        report_dict["key_value"] = False
-                        report_dict["message"] = (
-                            f'Invalid value type for "text" key on line {idx + 1}. '
-                            f'Expected string. Found {type(json_line["text"])}.'
-                        )
-
-                        report_dict["is_check_passed"] = False
-
-            # make sure this is outside the for idx, line in enumerate(f): for loop
-            if idx + 1 < MIN_SAMPLES:
-                report_dict["min_samples"] = False
-                report_dict["message"] = (
-                    f"Processing {file} resulted in only {idx + 1} samples. "
-                    f"Our minimum is {MIN_SAMPLES} samples. "
-                )
-                report_dict["is_check_passed"] = False
-            else:
-                report_dict["num_samples"] = idx + 1
-                report_dict["min_samples"] = True
-
-            report_dict["load_json"] = True
-
-        except ValueError:
-            report_dict["load_json"] = False
-            if idx < 0:
-                report_dict["message"] = (
-                    "Unable to decode file. "
-                    "File may be empty or in an unsupported format. "
-                )
-            else:
-                report_dict["message"] = (
-                    f"Error parsing json payload. Unexpected format on line {idx + 1}."
-                )
-            report_dict["is_check_passed"] = False
-
-    if "text_field" not in report_dict:
-        report_dict["text_field"] = True
-    if "line_type" not in report_dict:
-        report_dict["line_type"] = True
-    if "key_value" not in report_dict:
-        report_dict["key_value"] = True
-    return report_dict
-
-
-def _check_parquet(file: Path) -> Dict[str, Any]:
-    report_dict: Dict[str, Any] = {}
-
-    try:
-        table = parquet.read_table(str(file), memory_map=True)
-    except ArrowInvalid:
-        report_dict["load_parquet"] = (
-            f"An exception has occurred when loading the Parquet file {file}. Please check the file for corruption. "
-            f"Exception trace:\n{format_exc()}"
-        )
-        report_dict["is_check_passed"] = False
-        return report_dict
-
-    column_names = table.schema.names
-    if "input_ids" not in column_names:
-        report_dict["load_parquet"] = (
-            f"Parquet file {file} does not contain the `input_ids` column."
-        )
-        report_dict["is_check_passed"] = False
-        return report_dict
-
-    for column_name in column_names:
-        if column_name not in PARQUET_EXPECTED_COLUMNS:
-            report_dict["load_parquet"] = (
-                f"Parquet file {file} contains an unexpected column {column_name}. "
-                f"Only columns {PARQUET_EXPECTED_COLUMNS} are supported."
-            )
-            report_dict["is_check_passed"] = False
-            return report_dict
-
-    num_samples = len(table)
-    if num_samples < MIN_SAMPLES:
-        report_dict["min_samples"] = (
-            f"Processing {file} resulted in only {num_samples} samples. "
-            f"Our minimum is {MIN_SAMPLES} samples. "
-        )
-        report_dict["is_check_passed"] = False
-        return report_dict
-    else:
-        report_dict["num_samples"] = num_samples
-
-    report_dict["is_check_passed"] = True
-
-    return report_dict

together/version.py

@@ -1,6 +0,0 @@
-import importlib.metadata
-
-
-VERSION = importlib.metadata.version(
-    "together"
-)  # gets version number from pyproject.toml