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

together/cli/api/chat.py

@@ -1,276 +0,0 @@
-from __future__ import annotations
-
-import cmd
-import json
-from typing import 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("--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,
-    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 = [{"role": msg[0], "content": msg[1]} for msg in message]
-
-    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/models.py

@@ -1,55 +0,0 @@
-import json as json_lib
-
-import click
-from tabulate import tabulate
-
-from together import Together
-from together.types.models import ModelObject
-
-
-@click.group()
-@click.pass_context
-def models(ctx: click.Context) -> None:
-    """Models API commands"""
-    pass
-
-
-@models.command()
-@click.option(
-    "--type",
-    type=click.Choice(["dedicated"]),
-    help="Filter models by type (dedicated: models that can be deployed as dedicated endpoints)",
-)
-@click.option(
-    "--json",
-    is_flag=True,
-    help="Output in JSON format",
-)
-@click.pass_context
-def list(ctx: click.Context, type: str | None, json: bool) -> None:
-    """List models"""
-    client: Together = ctx.obj
-
-    response = client.models.list(dedicated=(type == "dedicated"))
-
-    display_list = []
-
-    model: ModelObject
-    for model in response:
-        display_list.append(
-            {
-                "ID": model.id,
-                "Name": model.display_name,
-                "Organization": model.organization,
-                "Type": model.type,
-                "Context Length": model.context_length,
-                "License": model.license,
-                "Input per 1M token": model.pricing.input,
-                "Output per 1M token": model.pricing.output,
-            }
-        )
-
-    if json:
-        click.echo(json_lib.dumps(display_list, indent=2))
-    else:
-        click.echo(tabulate(display_list, headers="keys", tablefmt="plain"))