together 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

together/commands/finetune.py

@@ -4,8 +4,14 @@ import argparse
 import json
 import os
 
+from tabulate import tabulate
+
+import together
 from together import Finetune
-from together.utils import parse_timestamp
+from together.utils import finetune_price_to_dollars, get_logger, parse_timestamp
+
+
+logger = get_logger(str(__name__))
 
 
 def add_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
@@ -22,7 +28,6 @@ def add_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser])
     _add_download(child_parsers)
     _add_status(child_parsers)
     _add_checkpoints(child_parsers)
-    # _add_delete_model(child_parsers)
 
 
 def _add_create(parser: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
@@ -43,13 +48,6 @@ def _add_create(parser: argparse._SubParsersAction[argparse.ArgumentParser]) ->
         required=False,
         action="store_true",
     )
-    # subparser.add_argument(
-    #     "--validation-file",
-    #     "-v",
-    #     default=None,
-    #     help="The ID of an uploaded file that contains validation data.",
-    #     type=str,
-    # )
     subparser.add_argument(
         "--model",
         "-m",
@@ -90,46 +88,6 @@ def _add_create(parser: argparse._SubParsersAction[argparse.ArgumentParser]) ->
         help="The learning rate multiplier to use for training. Default=0.00001",
         type=float,
     )
-    # subparser.add_argument(
-    #     "--warmup-steps",
-    #     "-ws",
-    #     default=0,
-    #     help="Warmup steps",
-    #     type=int,
-    # )
-    # subparser.add_argument(
-    #     "--train-warmup-steps",
-    #     "-tws",
-    #     default=0,
-    #     help="Train warmup steps",
-    #     type=int,
-    # )
-    # subparser.add_argument(
-    #     "--sequence-length",
-    #     "-sl",
-    #     default=2048,
-    #     help="Max sequence length",
-    #     type=int,
-    # )
-    # subparser.add_argument(
-    #     "--seed",
-    #     default=42,
-    #     help="Training seed",
-    #     type=int,
-    # )
-    # subparser.add_argument(
-    #     "--fp32",
-    #     help="Enable FP32 training. Defaults to false (FP16 training).",
-    #     default=False,
-    #     action="store_true",
-    # )
-    # subparser.add_argument(
-    #     "--checkpoint-steps",
-    #     "-b",
-    #     default=0,
-    #     help="Number of steps between each checkpoint. Defaults to 0 = checkpoints per epoch.",
-    #     type=int,
-    # )
     subparser.add_argument(
         "--suffix",
         "-s",
@@ -162,53 +120,69 @@ def _add_create(parser: argparse._SubParsersAction[argparse.ArgumentParser]) ->
 
     subparser.set_defaults(func=_run_create)
 
-    # End of create_finetune
-
 
 def _add_list(parser: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
     # List_Finetune
-    list_parser = parser.add_parser("list")
-    list_parser.set_defaults(func=_run_list)
+    subparser = parser.add_parser("list")
+    subparser.add_argument(
+        "--raw",
+        help="Raw JSON dump of response",
+        default=False,
+        action="store_true",
+    )
+    subparser.set_defaults(func=_run_list)
 
 
 def _add_retrieve(parser: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
-    retrieve_finetune_parser = parser.add_parser("retrieve")
-    retrieve_finetune_parser.add_argument(
+    subparser = parser.add_parser("retrieve")
+    subparser.add_argument(
         "fine_tune_id",
         metavar="FINETUNE-ID",
         default=None,
         help="Fine-tuning ID",
         type=str,
     )
-    retrieve_finetune_parser.set_defaults(func=_run_retrieve)
+    subparser.add_argument(
+        "--raw",
+        help="Raw JSON dump of response",
+        default=False,
+        action="store_true",
+    )
+    subparser.set_defaults(func=_run_retrieve)
 
 
 def _add_cancel(parser: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
     # Cancel Finetune
-    cancel_finetune_parser = parser.add_parser("cancel")
-    cancel_finetune_parser.add_argument(
+    subparser = parser.add_parser("cancel")
+    subparser.add_argument(
         "fine_tune_id",
         metavar="FINETUNE-ID",
         default=None,
         help="Fine-tuning ID",
         type=str,
     )
-    cancel_finetune_parser.set_defaults(func=_run_cancel)
+    subparser.set_defaults(func=_run_cancel)
 
 
 def _add_list_events(
     parser: argparse._SubParsersAction[argparse.ArgumentParser],
 ) -> None:
     # List finetune events
-    list_finetune_events_parser = parser.add_parser("list-events")
-    list_finetune_events_parser.add_argument(
+    subparser = parser.add_parser("list-events")
+    subparser.add_argument(
         "fine_tune_id",
         metavar="FINETUNE-ID",
         default=None,
         help="Fine-tuning ID",
         type=str,
     )
-    list_finetune_events_parser.set_defaults(func=_run_list_events)
+    subparser.add_argument(
+        "--raw",
+        help="Raw JSON dump of response",
+        default=False,
+        action="store_true",
+    )
+    subparser.set_defaults(func=_run_list_events)
 
 
 def _add_download(parser: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
@@ -269,22 +243,6 @@ def _add_checkpoints(
     checkpoint_parser.set_defaults(func=_run_checkpoint)
 
 
-# def _add_delete_model(
-#     parser: argparse._SubParsersAction[argparse.ArgumentParser],
-# ) -> None:
-#     # Delete finetune model
-#     delete_finetune_model_parser = parser.add_parser("delete-model")
-#     delete_finetune_model_parser.add_argument(
-#         "--model",
-#         "-m",
-#         default=None,
-#         help="Model name",
-#         type=str,
-#         required=True,
-#     )
-#     delete_finetune_model_parser.set_defaults(func=_run_delete_model)
-
-
 def _run_create(args: argparse.Namespace) -> None:
     finetune = Finetune()
 
@@ -297,70 +255,127 @@ def _run_create(args: argparse.Namespace) -> None:
             args.batch_size = 144
         else:
             args.batch_size = 32
-
-    response = finetune.create(
-        training_file=args.training_file,  # training file_id
-        # validation_file=args.validation_file,  # validation file_id
-        model=args.model,
-        n_epochs=args.n_epochs,
-        n_checkpoints=args.n_checkpoints,
-        batch_size=args.batch_size,
-        learning_rate=args.learning_rate,
-        # warmup_steps=args.warmup_steps,
-        # train_warmup_steps=args.train_warmup_steps,
-        # seq_length=args.sequence_length,
-        # seed=args.seed,
-        # fp16=not args.fp32,
-        # checkpoint_steps=args.checkpoint_steps,
-        suffix=args.suffix,
-        estimate_price=args.estimate_price,
-        wandb_api_key=args.wandb_api_key if not args.no_wandb_api_key else None,
-        confirm_inputs=not args.quiet,
-    )
+    try:
+        response = finetune.create(
+            training_file=args.training_file,  # training file_id
+            model=args.model,
+            n_epochs=args.n_epochs,
+            n_checkpoints=args.n_checkpoints,
+            batch_size=args.batch_size,
+            learning_rate=args.learning_rate,
+            suffix=args.suffix,
+            estimate_price=args.estimate_price,
+            wandb_api_key=args.wandb_api_key if not args.no_wandb_api_key else None,
+            confirm_inputs=not args.quiet,
+        )
+    except together.AuthenticationError:
+        logger.critical(together.MISSING_API_KEY_MESSAGE)
+        exit(0)
 
     print(json.dumps(response, indent=4))
 
 
 def _run_list(args: argparse.Namespace) -> None:
-    response = Finetune.list()
-    data_list = response["data"]
-    sorted_data = sorted(data_list, key=lambda x: parse_timestamp(x["created_at"]))
-    response["data"] = sorted_data
-    print(json.dumps(response, indent=4))
+    try:
+        response = Finetune.list()
+    except together.AuthenticationError:
+        logger.critical(together.MISSING_API_KEY_MESSAGE)
+        exit(0)
+    response["data"].sort(key=lambda x: parse_timestamp(x["created_at"]))
+    if args.raw:
+        print(json.dumps(response, indent=4))
+    else:
+        display_list = []
+        for i in response["data"]:
+            display_list.append(
+                {
+                    "Fine-tune ID": i.get("id"),
+                    "Model Output Name": i.get("model_output_name"),
+                    "Status": i.get("status"),
+                    "Created At": i.get("created_at"),
+                    "Price": finetune_price_to_dollars(
+                        float(str(i.get("total_price")))
+                    ),  # convert to string for mypy typing
+                }
+            )
+        table = tabulate(display_list, headers="keys", tablefmt="grid", showindex=True)
+        print(table)
 
 
 def _run_retrieve(args: argparse.Namespace) -> None:
-    response = Finetune.retrieve(args.fine_tune_id)
-    print(json.dumps(response, indent=4))
+    try:
+        response = Finetune.retrieve(args.fine_tune_id)
+    except together.AuthenticationError:
+        logger.critical(together.MISSING_API_KEY_MESSAGE)
+        exit(0)
+    if args.raw:
+        print(json.dumps(response, indent=4))
+    else:
+        table_data = [
+            {"Key": key, "Value": value}
+            for key, value in response.items()
+            if key not in ["events", "model_output_path"]
+        ]
+        table = tabulate(table_data, tablefmt="grid")
+        print(table)
 
 
 def _run_cancel(args: argparse.Namespace) -> None:
-    response = Finetune.cancel(args.fine_tune_id)
+    try:
+        response = Finetune.cancel(args.fine_tune_id)
+    except together.AuthenticationError:
+        logger.critical(together.MISSING_API_KEY_MESSAGE)
+        exit(0)
     print(json.dumps(response, indent=4))
 
 
 def _run_list_events(args: argparse.Namespace) -> None:
-    response = Finetune.list_events(args.fine_tune_id)
-    print(json.dumps(response, indent=4))
+    try:
+        response = Finetune.list_events(args.fine_tune_id)
+    except together.AuthenticationError:
+        logger.critical(together.MISSING_API_KEY_MESSAGE)
+        exit(0)
+    if args.raw:
+        print(json.dumps(response, indent=4))
+    else:
+        display_list = []
+        for i in response["data"]:
+            display_list.append(
+                {
+                    "Message": i.get("message"),
+                    "Type": i.get("type"),
+                    "Hash": i.get("hash"),
+                }
+            )
+        table = tabulate(display_list, headers="keys", tablefmt="grid", showindex=True)
+        print(table)
 
 
 def _run_download(args: argparse.Namespace) -> None:
-    response = Finetune.download(args.fine_tune_id, args.output, args.checkpoint_step)
+    try:
+        response = Finetune.download(
+            args.fine_tune_id, args.output, args.checkpoint_step
+        )
+    except together.AuthenticationError:
+        logger.critical(together.MISSING_API_KEY_MESSAGE)
+        exit(0)
     print(response)
 
 
 def _run_status(args: argparse.Namespace) -> None:
-    response = Finetune.get_job_status(args.fine_tune_id)
+    try:
+        response = Finetune.get_job_status(args.fine_tune_id)
+    except together.AuthenticationError:
+        logger.critical(together.MISSING_API_KEY_MESSAGE)
+        exit(0)
     print(response)
 
 
 def _run_checkpoint(args: argparse.Namespace) -> None:
-    checkpoints = Finetune.get_checkpoints(args.fine_tune_id)
+    try:
+        checkpoints = Finetune.get_checkpoints(args.fine_tune_id)
+    except together.AuthenticationError:
+        logger.critical(together.MISSING_API_KEY_MESSAGE)
+        exit(0)
     print(json.dumps(checkpoints, indent=4))
     print(f"\n{len(checkpoints)} checkpoints found")
-
-
-# def _run_delete_model(args: argparse.Namespace) -> None:
-#     finetune = Finetune(args.endpoint)
-#     response = finetune.delete_finetune_model(args.model)
-#     print(json.dumps(response))

together/commands/image.py

@@ -124,16 +124,19 @@ def _save_image(args: argparse.Namespace, response: Dict[str, Any]) -> None:
 
 def _run_complete(args: argparse.Namespace) -> None:
     complete = Image()
-
-    response = complete.create(
-        prompt=args.prompt,
-        model=args.model,
-        steps=args.steps,
-        seed=args.seed,
-        results=args.results,
-        height=args.height,
-        width=args.width,
-        negative_prompt=args.negative_prompt,
-    )
+    try:
+        response = complete.create(
+            prompt=args.prompt,
+            model=args.model,
+            steps=args.steps,
+            seed=args.seed,
+            results=args.results,
+            height=args.height,
+            width=args.width,
+            negative_prompt=args.negative_prompt,
+        )
+    except together.AuthenticationError:
+        logger.critical(together.MISSING_API_KEY_MESSAGE)
+        exit(0)
 
     _save_image(args, response)

together/commands/models.py

@@ -3,7 +3,13 @@ from __future__ import annotations
 import argparse
 import json
 
+from tabulate import tabulate
+
 import together
+from together.utils import get_logger
+
+
+logger = get_logger(str(__name__))
 
 
 def add_parser(
@@ -26,9 +32,15 @@ def _add_list(
     parser: argparse._SubParsersAction[argparse.ArgumentParser],
 ) -> None:
     subparser = parser.add_parser("list")
+    subparser.add_argument(
+        "--details",
+        help="List all details",
+        default=False,
+        action="store_true",
+    )
     subparser.add_argument(
         "--raw",
-        help="Raw details of all models",
+        help="Raw JSON dump of response",
         default=False,
         action="store_true",
     )
@@ -107,18 +119,51 @@ def _add_ready(
 
 
 def _run_list(args: argparse.Namespace) -> None:
-    response = together.Models.list()
+    try:
+        response = together.Models.list()
+    except together.AuthenticationError:
+        logger.critical(together.MISSING_API_KEY_MESSAGE)
+        exit(0)
     if args.raw:
         print(json.dumps(response, indent=4))
     else:
-        model_list = []
-        for i in response:
-            model_list.append(i["name"])
-        print(json.dumps(model_list, indent=4))
+        if not args.details:
+            display_list = []
+            for i in response:
+                display_list.append(
+                    {
+                        "Name": i.get("display_name"),
+                        "Model String": i.get("name"),
+                        "Type": i.get("display_type"),
+                    }
+                )
+        else:
+            display_list = []
+            for i in response:
+                display_list.append(
+                    {
+                        "Name": i.get("display_name"),
+                        "Model String": i.get("name"),
+                        "Type": i.get("display_type"),
+                        "Parameters": i.get("num_parameters"),
+                        "Context": i.get("context_length"),
+                        "Hardware": i.get("hardware_label"),
+                    }
+                )
+        table = tabulate(display_list, headers="keys", tablefmt="grid")
+        print(table)
 
 
 def _run_info(args: argparse.Namespace) -> None:
-    if not args.raw:
+    try:
+        model_info = together.Models.info(args.model)
+    except together.AuthenticationError:
+        logger.critical(together.MISSING_API_KEY_MESSAGE)
+        exit(0)
+
+    if args.raw:
+        print(json.dumps(model_info, indent=4))
+    else:
         hidden_keys = [
             "_id",
             "modelInstanceConfig",
@@ -130,17 +175,25 @@ def _run_info(args: argparse.Namespace) -> None:
             "pricing_tier",
             "hardware_label",
             "depth",
+            "descriptionLink",
         ]
-    else:
-        hidden_keys = []
 
-    model_info = together.Models.info(args.model, hidden_keys=hidden_keys)
-
-    print(json.dumps(model_info, indent=4))
+        table_data = [
+            {"Key": key, "Value": value}
+            for key, value in model_info.items()
+            if key not in hidden_keys
+        ]
+        table = tabulate(table_data, tablefmt="grid")
+        print(table)
 
 
 def _run_instances(args: argparse.Namespace) -> None:
-    response = together.Models.instances()
+    try:
+        response = together.Models.instances()
+    except together.AuthenticationError:
+        logger.critical(together.MISSING_API_KEY_MESSAGE)
+        exit(0)
+
     if args.raw:
         print(json.dumps(response, indent=4))
     else:
@@ -149,15 +202,27 @@ def _run_instances(args: argparse.Namespace) -> None:
 
 
 def _run_start(args: argparse.Namespace) -> None:
-    response = together.Models.start(args.model)
+    try:
+        response = together.Models.start(args.model)
+    except together.AuthenticationError:
+        logger.critical(together.MISSING_API_KEY_MESSAGE)
+        exit(0)
     print(json.dumps(response, indent=4))
 
 
 def _run_stop(args: argparse.Namespace) -> None:
-    response = together.Models.stop(args.model)
+    try:
+        response = together.Models.stop(args.model)
+    except together.AuthenticationError:
+        logger.critical(together.MISSING_API_KEY_MESSAGE)
+        exit(0)
     print(json.dumps(response, indent=4))
 
 
 def _run_ready(args: argparse.Namespace) -> None:
-    response = together.Models.ready(args.model)
+    try:
+        response = together.Models.ready(args.model)
+    except together.AuthenticationError:
+        logger.critical(together.MISSING_API_KEY_MESSAGE)
+        exit(0)
     print(json.dumps(response, indent=4))

together/complete.py

@@ -41,8 +41,7 @@ class Complete:
         response = create_post_request(
             url=together.api_base_complete, json=parameter_payload
         )
-        if not response:
-            return {}
+
         try:
             response_json = dict(response.json())
 
@@ -86,8 +85,7 @@ class Complete:
         response = create_post_request(
             url=together.api_base_complete, json=parameter_payload, stream=True
         )
-        if not response:
-            return {}
+
         output = ""
         client = sse_client(response)
         for event in client.events():

together/embeddings.py

@@ -0,0 +1,35 @@
+from typing import Any, Dict, Optional
+
+import together
+from together.utils import create_post_request, get_logger
+
+
+logger = get_logger(str(__name__))
+
+
+class Embeddings:
+    @classmethod
+    def create(
+        self,
+        input: str,
+        model: Optional[str] = "",
+    ) -> Dict[str, Any]:
+        if model == "":
+            model = together.default_embedding_model
+
+        parameter_payload = {
+            "input": input,
+            "model": model,
+        }
+
+        # send request
+        response = create_post_request(
+            url=together.api_base_embeddings, json=parameter_payload
+        )
+
+        try:
+            response_json = dict(response.json())
+
+        except Exception as e:
+            raise together.JSONError(e, http_status=response.status_code)
+        return response_json

together/error.py

@@ -75,6 +75,10 @@ class InstanceError(TogetherException):
         )
 
 
+class RateLimitError(TogetherException):
+    pass
+
+
 class FileTypeError(TogetherException):
     pass
 

together/files.py

@@ -5,8 +5,10 @@ import urllib.parse
 from typing import Any, Dict, List, Mapping, Optional, Union
 
 import requests
+from requests.adapters import HTTPAdapter
 from tqdm import tqdm
 from tqdm.utils import CallbackIOWrapper
+from urllib3.util import Retry
 
 import together
 from together.utils import (
@@ -27,11 +29,10 @@ logger = get_logger(str(__name__))
 
 class Files:
     @classmethod
-    def list(self) -> Dict[str, List[Dict[str, Union[str, int]]]]:
+    def list(self) -> Dict[str, List[Dict[str, Union[str, int, float]]]]:
         # send request
         response = create_get_request(together.api_base_files)
-        if not response:
-            return {}
+
         return response_to_dict(response)
 
     @classmethod
@@ -63,6 +64,13 @@ class Files:
 
         session = requests.Session()
 
+        retry_strategy = Retry(
+            total=together.MAX_CONNECTION_RETRIES,
+            backoff_factor=together.BACKOFF_FACTOR,
+        )
+        retry_adapter = HTTPAdapter(max_retries=retry_strategy)
+        session.mount("https://", retry_adapter)
+
         init_endpoint = together.api_base_files[:-1]
 
         logger.debug(
@@ -133,10 +141,6 @@ class Files:
             logger.critical(f"Response error raised: {e}")
             raise together.ResponseError(e)
 
-        # output_dict["filename"] = os.path.basename(file)
-        # output_dict["id"] = str(file_id)
-        # output_dict["object"] = "file"
-
         return {
             "filename": os.path.basename(file),
             "id": str(file_id),
@@ -168,8 +172,7 @@ class Files:
         retrieve_url = urllib.parse.urljoin(together.api_base_files, file_id)
         logger.info(f"Retrieve URL: {retrieve_url}")
         response = create_get_request(retrieve_url)
-        if not response:
-            return {}
+
         return response_to_dict(response)
 
     @classmethod