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

together/cli/api/chat.py

@@ -1,298 +0,0 @@
-from __future__ import annotations
-
-import cmd
-import json
-from typing import Any, Dict, List, Tuple
-
-import click
-
-from together import Together
-from together.types.chat_completions import (
-    ChatCompletionChoicesChunk,
-    ChatCompletionChunk,
-    ChatCompletionResponse,
-)
-
-
-class ChatShell(cmd.Cmd):
-    intro = "Type /exit to exit, /help, or /? to list commands.\n"
-    prompt = ">>> "
-
-    def __init__(
-        self,
-        client: Together,
-        model: str,
-        max_tokens: int | None = None,
-        stop: List[str] | None = None,
-        temperature: float | None = None,
-        top_p: float | None = None,
-        top_k: int | None = None,
-        repetition_penalty: float | None = None,
-        presence_penalty: float | None = None,
-        frequency_penalty: float | None = None,
-        min_p: float | None = None,
-        safety_model: str | None = None,
-        system_message: str | None = None,
-    ) -> None:
-        super().__init__()
-        self.client = client
-        self.model = model
-        self.max_tokens = max_tokens
-        self.stop = stop
-        self.temperature = temperature
-        self.top_p = top_p
-        self.top_k = top_k
-        self.repetition_penalty = repetition_penalty
-        self.presence_penalty = presence_penalty
-        self.frequency_penalty = frequency_penalty
-        self.min_p = min_p
-        self.safety_model = safety_model
-        self.system_message = system_message
-
-        self.messages = (
-            [{"role": "system", "content": self.system_message}]
-            if self.system_message
-            else []
-        )
-
-    def precmd(self, line: str) -> str:
-        if line.startswith("/"):
-            return line[1:]
-        else:
-            return "say " + line
-
-    def do_say(self, arg: str) -> None:
-        self.messages.append({"role": "user", "content": arg})
-
-        output = ""
-
-        for chunk in self.client.chat.completions.create(
-            messages=self.messages,
-            model=self.model,
-            max_tokens=self.max_tokens,
-            stop=self.stop,
-            temperature=self.temperature,
-            top_p=self.top_p,
-            top_k=self.top_k,
-            repetition_penalty=self.repetition_penalty,
-            presence_penalty=self.presence_penalty,
-            frequency_penalty=self.frequency_penalty,
-            min_p=self.min_p,
-            safety_model=self.safety_model,
-            stream=True,
-        ):
-            # assertions for type checking
-            assert isinstance(chunk, ChatCompletionChunk)
-            assert chunk.choices
-            assert chunk.choices[0].delta
-
-            token = chunk.choices[0].delta.content
-
-            click.echo(token, nl=False)
-
-            output += token or ""
-
-        click.echo("\n")
-
-        self.messages.append({"role": "assistant", "content": output})
-
-    def do_reset(self, arg: str) -> None:
-        self.messages = (
-            [{"role": "system", "content": self.system_message}]
-            if self.system_message
-            else []
-        )
-
-    def do_exit(self, arg: str) -> bool:
-        return True
-
-
-@click.command(name="chat.interactive")
-@click.pass_context
-@click.option("--model", type=str, required=True, help="Model name")
-@click.option("--max-tokens", type=int, help="Max tokens to generate")
-@click.option(
-    "--stop", type=str, multiple=True, help="List of strings to stop generation"
-)
-@click.option("--temperature", type=float, help="Sampling temperature")
-@click.option("--top-p", type=int, help="Top p sampling")
-@click.option("--top-k", type=float, help="Top k sampling")
-@click.option("--repetition-penalty", type=float, help="Repetition penalty")
-@click.option("--presence-penalty", type=float, help="Presence penalty")
-@click.option("--frequency-penalty", type=float, help="Frequency penalty")
-@click.option("--min-p", type=float, help="Minimum p")
-@click.option("--safety-model", type=str, help="Moderation model")
-@click.option("--system-message", type=str, help="System message to use for the chat")
-def interactive(
-    ctx: click.Context,
-    model: str,
-    max_tokens: int | None = None,
-    stop: List[str] | None = None,
-    temperature: float | None = None,
-    top_p: float | None = None,
-    top_k: int | None = None,
-    repetition_penalty: float | None = None,
-    presence_penalty: float | None = None,
-    frequency_penalty: float | None = None,
-    min_p: float | None = None,
-    safety_model: str | None = None,
-    system_message: str | None = None,
-) -> None:
-    """Interactive chat shell"""
-    client: Together = ctx.obj
-
-    ChatShell(
-        client=client,
-        model=model,
-        max_tokens=max_tokens,
-        stop=stop,
-        temperature=temperature,
-        top_p=top_p,
-        top_k=top_k,
-        repetition_penalty=repetition_penalty,
-        presence_penalty=presence_penalty,
-        frequency_penalty=frequency_penalty,
-        min_p=min_p,
-        safety_model=safety_model,
-        system_message=system_message,
-    ).cmdloop()
-
-
-@click.command(name="chat.completions")
-@click.pass_context
-@click.option(
-    "--message",
-    type=(str, str),
-    multiple=True,
-    required=True,
-    help="Message to generate chat completions from",
-)
-@click.option("--model", type=str, required=True, help="Model name")
-@click.option("--max-tokens", type=int, help="Max tokens to generate")
-@click.option(
-    "--stop", type=str, multiple=True, help="List of strings to stop generation"
-)
-@click.option("--temperature", type=float, help="Sampling temperature")
-@click.option("--top-p", type=int, help="Top p sampling")
-@click.option("--top-k", type=float, help="Top k sampling")
-@click.option("--repetition-penalty", type=float, help="Repetition penalty")
-@click.option("--presence-penalty", type=float, help="Presence penalty sampling method")
-@click.option(
-    "--frequency-penalty", type=float, help="Frequency penalty sampling method"
-)
-@click.option("--min-p", type=float, help="Min p sampling")
-@click.option(
-    "--audio-url",
-    type=str,
-    multiple=True,
-    help="Audio URL to attach to the last user message",
-)
-@click.option("--no-stream", is_flag=True, help="Disable streaming")
-@click.option("--logprobs", type=int, help="Return logprobs. Only works with --raw.")
-@click.option("--echo", is_flag=True, help="Echo prompt. Only works with --raw.")
-@click.option("--n", type=int, help="Number of output generations")
-@click.option("--safety-model", type=str, help="Moderation model")
-@click.option("--raw", is_flag=True, help="Output raw JSON")
-def chat(
-    ctx: click.Context,
-    message: List[Tuple[str, str]],
-    model: str,
-    max_tokens: int | None = None,
-    stop: List[str] | None = None,
-    temperature: float | None = None,
-    top_p: float | None = None,
-    top_k: int | None = None,
-    repetition_penalty: float | None = None,
-    presence_penalty: float | None = None,
-    frequency_penalty: float | None = None,
-    min_p: float | None = None,
-    audio_url: List[str] | None = None,
-    no_stream: bool = False,
-    logprobs: int | None = None,
-    echo: bool | None = None,
-    n: int | None = None,
-    safety_model: str | None = None,
-    raw: bool = False,
-) -> None:
-    """Generate chat completions from messages"""
-    client: Together = ctx.obj
-
-    messages: List[Dict[str, Any]] = [
-        {"role": msg[0], "content": msg[1]} for msg in message
-    ]
-
-    if audio_url and messages:
-        last_msg = messages[-1]
-        if last_msg["role"] == "user":
-            # Convert content to list if it is string
-            if isinstance(last_msg["content"], str):
-                last_msg["content"] = [{"type": "text", "text": last_msg["content"]}]
-
-            # Append audio URLs
-            for url in audio_url:
-                last_msg["content"].append(
-                    {"type": "audio_url", "audio_url": {"url": url}}
-                )
-
-    response = client.chat.completions.create(
-        model=model,
-        messages=messages,
-        top_p=top_p,
-        top_k=top_k,
-        temperature=temperature,
-        max_tokens=max_tokens,
-        stop=stop,
-        repetition_penalty=repetition_penalty,
-        presence_penalty=presence_penalty,
-        frequency_penalty=frequency_penalty,
-        min_p=min_p,
-        stream=not no_stream,
-        logprobs=logprobs,
-        echo=echo,
-        n=n,
-        safety_model=safety_model,
-    )
-
-    if not no_stream:
-        for chunk in response:
-            # assertions for type checking
-            assert isinstance(chunk, ChatCompletionChunk)
-            assert chunk.choices
-
-            if raw:
-                click.echo(f"{json.dumps(chunk.model_dump(exclude_none=True))}")
-                continue
-
-            should_print_header = len(chunk.choices) > 1
-            for stream_choice in sorted(chunk.choices, key=lambda c: c.index):  # type: ignore
-                assert isinstance(stream_choice, ChatCompletionChoicesChunk)
-                assert stream_choice.delta
-
-                if should_print_header:
-                    click.echo(f"\n===== Completion {stream_choice.index} =====\n")
-                click.echo(f"{stream_choice.delta.content}", nl=False)
-
-                if should_print_header:
-                    click.echo("\n")
-
-        # new line after stream ends
-        click.echo("\n")
-    else:
-        # assertions for type checking
-        assert isinstance(response, ChatCompletionResponse)
-        assert isinstance(response.choices, list)
-
-        if raw:
-            click.echo(
-                f"{json.dumps(response.model_dump(exclude_none=True), indent=4)}"
-            )
-            return
-
-        should_print_header = len(response.choices) > 1
-        for i, choice in enumerate(response.choices):
-            if should_print_header:
-                click.echo(f"===== Completion {i} =====")
-            click.echo(choice.message.content)  # type: ignore
-
-            if should_print_header:
-                click.echo("\n")

together/cli/api/completions.py

@@ -1,119 +0,0 @@
-from __future__ import annotations
-
-import json
-from typing import List
-
-import click
-
-from together import Together
-from together.types import CompletionChunk
-from together.types.completions import CompletionChoicesChunk, CompletionResponse
-
-
-@click.command()
-@click.pass_context
-@click.argument("prompt", type=str, required=True)
-@click.option("--model", type=str, required=True, help="Model name")
-@click.option("--max-tokens", type=int, help="Max tokens to generate")
-@click.option(
-    "--stop", type=str, multiple=True, help="List of strings to stop generation"
-)
-@click.option("--temperature", type=float, help="Sampling temperature")
-@click.option("--top-p", type=int, help="Top p sampling")
-@click.option("--top-k", type=float, help="Top k sampling")
-@click.option("--repetition-penalty", type=float, help="Repetition penalty")
-@click.option("--presence-penalty", type=float, help="Presence penalty")
-@click.option("--frequency-penalty", type=float, help="Frequency penalty")
-@click.option("--min-p", type=float, help="Minimum p")
-@click.option("--no-stream", is_flag=True, help="Disable streaming")
-@click.option("--logprobs", type=int, help="Return logprobs. Only works with --raw.")
-@click.option("--echo", is_flag=True, help="Echo prompt. Only works with --raw.")
-@click.option("--n", type=int, help="Number of output generations")
-@click.option("--safety-model", type=str, help="Moderation model")
-@click.option("--raw", is_flag=True, help="Return raw JSON response")
-def completions(
-    ctx: click.Context,
-    prompt: str,
-    model: str,
-    max_tokens: int | None = 512,
-    stop: List[str] | None = None,
-    temperature: float | None = None,
-    top_p: float | None = None,
-    top_k: int | None = None,
-    repetition_penalty: float | None = None,
-    presence_penalty: float | None = None,
-    frequency_penalty: float | None = None,
-    min_p: float | None = None,
-    no_stream: bool = False,
-    logprobs: int | None = None,
-    echo: bool | None = None,
-    n: int | None = None,
-    safety_model: str | None = None,
-    raw: bool = False,
-) -> None:
-    """Generate text completions"""
-    client: Together = ctx.obj
-
-    response = client.completions.create(
-        model=model,
-        prompt=prompt,
-        top_p=top_p,
-        top_k=top_k,
-        temperature=temperature,
-        max_tokens=max_tokens,
-        stop=stop,
-        repetition_penalty=repetition_penalty,
-        presence_penalty=presence_penalty,
-        frequency_penalty=frequency_penalty,
-        min_p=min_p,
-        stream=not no_stream,
-        logprobs=logprobs,
-        echo=echo,
-        n=n,
-        safety_model=safety_model,
-    )
-
-    if not no_stream:
-        for chunk in response:
-            # assertions for type checking
-            assert isinstance(chunk, CompletionChunk)
-            assert chunk.choices
-
-            if raw:
-                click.echo(f"{json.dumps(chunk.model_dump(exclude_none=True))}")
-                continue
-
-            should_print_header = len(chunk.choices) > 1
-            for stream_choice in sorted(chunk.choices, key=lambda c: c.index):  # type: ignore
-                # assertions for type checking
-                assert isinstance(stream_choice, CompletionChoicesChunk)
-                assert stream_choice.delta
-
-                if should_print_header:
-                    click.echo(f"\n===== Completion {stream_choice.index} =====\n")
-                click.echo(f"{stream_choice.delta.content}", nl=False)
-
-                if should_print_header:
-                    click.echo("\n")
-
-        # new line after stream ends
-        click.echo("\n")
-    else:
-        # assertions for type checking
-        assert isinstance(response, CompletionResponse)
-        assert isinstance(response.choices, list)
-
-        if raw:
-            click.echo(
-                f"{json.dumps(response.model_dump(exclude_none=True), indent=4)}"
-            )
-            return
-
-        should_print_header = len(response.choices) > 1
-        for i, choice in enumerate(response.choices):
-            if should_print_header:
-                click.echo(f"===== Completion {i} =====")
-            click.echo(choice.text)
-
-            if should_print_header or not choice.text.endswith("\n"):
-                click.echo("\n")

together/cli/api/images.py

@@ -1,93 +0,0 @@
-import base64
-import pathlib
-import requests
-
-import click
-from PIL import Image
-
-from together import Together
-from together.types import ImageResponse
-from together.types.images import ImageChoicesData
-
-
-@click.group()
-@click.pass_context
-def images(ctx: click.Context) -> None:
-    """Images generations API commands"""
-    pass
-
-
-@images.command()
-@click.pass_context
-@click.argument("prompt", type=str, required=True)
-@click.option("--model", type=str, required=True, help="Model name")
-@click.option("--steps", type=int, default=20, help="Number of steps to run generation")
-@click.option("--seed", type=int, default=None, help="Random seed")
-@click.option("--n", type=int, default=1, help="Number of images to generate")
-@click.option("--height", type=int, default=1024, help="Image height")
-@click.option("--width", type=int, default=1024, help="Image width")
-@click.option("--negative-prompt", type=str, default=None, help="Negative prompt")
-@click.option(
-    "--output",
-    type=click.Path(exists=True, file_okay=False, resolve_path=True),
-    required=False,
-    default=pathlib.Path("."),
-    help="Output directory",
-)
-@click.option("--prefix", type=str, required=False, default="image-")
-@click.option("--no-show", is_flag=True, help="Do not open images in viewer")
-def generate(
-    ctx: click.Context,
-    prompt: str,
-    model: str,
-    steps: int,
-    seed: int,
-    n: int,
-    height: int,
-    width: int,
-    negative_prompt: str,
-    output: pathlib.Path,
-    prefix: str,
-    no_show: bool,
-) -> None:
-    """Generate image"""
-
-    client: Together = ctx.obj
-
-    response = client.images.generate(
-        prompt=prompt,
-        model=model,
-        steps=steps,
-        seed=seed,
-        n=n,
-        height=height,
-        width=width,
-        negative_prompt=negative_prompt,
-    )
-
-    assert isinstance(response, ImageResponse)
-    assert isinstance(response.data, list)
-
-    for i, choice in enumerate(response.data):
-        assert isinstance(choice, ImageChoicesData)
-
-        data = None
-        if choice.b64_json:
-            data = base64.b64decode(choice.b64_json)
-        elif choice.url:
-            data = requests.get(choice.url).content
-
-        if not data:
-            click.echo(f"Image [{i + 1}/{len(response.data)}] is empty")
-            continue
-
-        with open(f"{output}/{prefix}{choice.index}.png", "wb") as f:
-            f.write(data)
-
-        click.echo(
-            f"Image [{i + 1}/{len(response.data)}] saved to {output}/{prefix}{choice.index}.png"
-        )
-
-        if not no_show:
-            image = Image.open(f"{output}/{prefix}{choice.index}.png")
-            image.show()

together/cli/api/utils.py

@@ -1,139 +0,0 @@
-from __future__ import annotations
-
-import math
-import re
-from gettext import gettext as _
-from typing import Literal
-from datetime import datetime
-
-import click
-
-from together.types.finetune import FinetuneResponse, COMPLETED_STATUSES
-
-_PROGRESS_BAR_WIDTH = 40
-
-
-class AutoIntParamType(click.ParamType):
-    name = "integer_or_max"
-    _number_class = int
-
-    def convert(
-        self, value: str, param: click.Parameter | None, ctx: click.Context | None
-    ) -> int | Literal["max"] | None:
-        if value == "max":
-            return "max"
-        try:
-            return int(value)
-        except ValueError:
-            self.fail(
-                _("{value!r} is not a valid {number_type}.").format(
-                    value=value, number_type=self.name
-                ),
-                param,
-                ctx,
-            )
-
-
-class BooleanWithAutoParamType(click.ParamType):
-    name = "boolean_or_auto"
-
-    def convert(
-        self, value: str, param: click.Parameter | None, ctx: click.Context | None
-    ) -> bool | Literal["auto"] | None:
-        if value == "auto":
-            return "auto"
-        try:
-            return bool(value)
-        except ValueError:
-            self.fail(
-                _("{value!r} is not a valid {type}.").format(
-                    value=value, type=self.name
-                ),
-                param,
-                ctx,
-            )
-
-
-INT_WITH_MAX = AutoIntParamType()
-BOOL_WITH_AUTO = BooleanWithAutoParamType()
-
-
-def _human_readable_time(timedelta: float) -> str:
-    """Convert a timedelta to a compact human-readble string
-    Examples:
-        00:00:10 -> 10s
-        01:23:45 -> 1h 23min 45s
-        1 Month 23 days 04:56:07 -> 1month 23d 4h 56min 7s
-    Args:
-        timedelta (float): The timedelta in seconds to convert.
-    Returns:
-        A string representing the timedelta in a human-readable format.
-    """
-    units = [
-        (30 * 24 * 60 * 60, "month"),  # 30 days
-        (24 * 60 * 60, "d"),
-        (60 * 60, "h"),
-        (60, "min"),
-        (1, "s"),
-    ]
-
-    total_seconds = int(timedelta)
-    parts = []
-
-    for unit_seconds, unit_name in units:
-        if total_seconds >= unit_seconds:
-            value = total_seconds // unit_seconds
-            total_seconds %= unit_seconds
-            parts.append(f"{value}{unit_name}")
-
-    return " ".join(parts) if parts else "0s"
-
-
-def generate_progress_bar(
-    finetune_job: FinetuneResponse, current_time: datetime, use_rich: bool = False
-) -> str:
-    """Generate a progress bar for a finetune job.
-    Args:
-        finetune_job: The finetune job to generate a progress bar for.
-        current_time: The current time.
-        use_rich: Whether to use rich formatting.
-    Returns:
-        A string representing the progress bar.
-    """
-    progress = "Progress: [bold red]unavailable[/bold red]"
-    if finetune_job.status in COMPLETED_STATUSES:
-        progress = "Progress: [bold green]completed[/bold green]"
-    elif finetune_job.started_at is not None:
-        # Replace 'Z' with '+00:00' for Python 3.10 compatibility
-        started_at_str = finetune_job.started_at.replace("Z", "+00:00")
-        started_at = datetime.fromisoformat(started_at_str).astimezone()
-
-        if finetune_job.progress is not None:
-            if current_time < started_at:
-                return progress
-
-            if not finetune_job.progress.estimate_available:
-                return progress
-
-            if finetune_job.progress.seconds_remaining <= 0:
-                return progress
-
-            elapsed_time = (current_time - started_at).total_seconds()
-            ratio_filled = min(
-                elapsed_time / finetune_job.progress.seconds_remaining, 1.0
-            )
-            percentage = ratio_filled * 100
-            filled = math.ceil(ratio_filled * _PROGRESS_BAR_WIDTH)
-            bar = "█" * filled + "░" * (_PROGRESS_BAR_WIDTH - filled)
-            time_left = "N/A"
-            if finetune_job.progress.seconds_remaining > elapsed_time:
-                time_left = _human_readable_time(
-                    finetune_job.progress.seconds_remaining - elapsed_time
-                )
-            time_text = f"{time_left} left"
-            progress = f"Progress: {bar} [bold]{percentage:>3.0f}%[/bold] [yellow]{time_text}[/yellow]"
-
-    if use_rich:
-        return progress
-
-    return re.sub(r"\[/?[^\]]+\]", "", progress)