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

together/__init__.py

@@ -1,17 +1,12 @@
 import os
+import sys
 import urllib.parse
 
-from .config import (
-    finetune_model_names,
-    jokes_list,
-    min_samples,
-    model_info_dict,
-)
 from .version import VERSION
 
 
 version = VERSION
-# print(version)
+
 user_agent = f"TogetherPythonOfficial/{version}"
 
 api_key = os.environ.get("TOGETHER_API_KEY", None)
@@ -26,6 +21,8 @@ default_text_model = "togethercomputer/RedPajama-INCITE-7B-Chat"
 default_image_model = "runwayml/stable-diffusion-v1-5"
 log_level = "WARNING"
 
+min_samples = 100
+
 from .complete import Complete
 from .error import *
 from .files import Files
@@ -48,8 +45,5 @@ __all__ = [
     "Files",
     "Finetune",
     "Image",
-    "model_info_dict",
-    "finetune_model_names",
     "min_samples",
-    "jokes_list",
 ]

together/cli/cli.py

@@ -3,7 +3,10 @@ import argparse
 
 import together
 from together.commands import chat, complete, files, finetune, image, models
-from together.utils.utils import get_logger
+from together.utils import get_logger
+
+
+logger = get_logger(str(__name__))
 
 
 def main() -> None:
@@ -29,9 +32,10 @@ def main() -> None:
     )
 
     parser.add_argument(
-        "--log",
+        "--verbose",
+        "-v",
         default=together.log_level,
-        choices=["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"],
+        choices=["CRITICAL", "ERROR", "WARNING", "SUCCESS", "INFO", "DEBUG", "TRACE"],
         type=str,
         help="Set logging level. Defaults to WARNING. DEBUG will show all logs.",
         required=False,
@@ -49,12 +53,7 @@ def main() -> None:
     args = parser.parse_args()
 
     # Setup logging
-    try:
-        get_logger(__name__, log_level=args.log)
-    except Exception:
-        get_logger(__name__, log_level=together.log_level)
-
-    together.log_level = args.log
+    together.log_level = args.verbose
 
     try:
         args.func(args)

together/commands/chat.py

@@ -4,14 +4,11 @@ import argparse
 import cmd
 
 import together
-import together.utils.conversation as convo
+import together.tools.conversation as convo
 from together import Complete
-from together.utils.utils import get_logger
 
 
-def add_parser(
-    subparsers: argparse._SubParsersAction[argparse.ArgumentParser],
-) -> None:
+def add_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
     COMMAND_NAME = "chat"
     subparser = subparsers.add_parser(COMMAND_NAME)
 
@@ -128,7 +125,6 @@ class OpenChatKitShell(cmd.Cmd):
 
 
 def _run_complete(args: argparse.Namespace) -> None:
-    get_logger(__name__, log_level=args.log)
     if args.prompt_id not in args.stop:
         args.stop.append(args.prompt_id)
 

together/commands/complete.py

@@ -2,19 +2,18 @@ from __future__ import annotations
 
 import argparse
 import json
-import logging
 import re
-import sys
 from typing import Any, Dict, List
 
 import together
 from together import Complete
-from together.utils.utils import get_logger
+from together.utils import get_logger
 
 
-def add_parser(
-    subparsers: argparse._SubParsersAction[argparse.ArgumentParser],
-) -> None:
+logger = get_logger(str(__name__))
+
+
+def add_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
     COMMAND_NAME = "complete"
     subparser = subparsers.add_parser(COMMAND_NAME)
 
@@ -99,46 +98,36 @@ def _enforce_stop_tokens(text: str, stop: List[str]) -> str:
     return re.split("|".join(stop), text)[0]
 
 
-def no_streamer(
-    args: argparse.Namespace, response: Dict[str, Any], logger: logging.Logger
-) -> None:
+def no_streamer(args: argparse.Namespace, response: Dict[str, Any]) -> None:
     if args.raw:
         print(json.dumps(response, indent=4))
-        sys.exit()
-
-    if "output" in response.keys():
-        try:
-            text = str(response["output"]["choices"][0]["text"])
-        except Exception:
-            try:
-                logger.critical(f"Error raised: {response['output']['error']}")
-                raise together.ResponseError(response["output"]["error"])
-            except Exception as e:
-                logger.critical(f"Error raised: {e}")
-                raise together.ResponseError(e)
-
-        # if args.stop is not None:
-        #    text = _enforce_stop_tokens(text, args.stop)
-
-    elif "error" in response.keys():
-        if response["error"] == "Returned error: no instance":
-            logger.critical(
-                f"No running instances for {args.model}. You can start an instance by navigating to the Together Playground at api.together.xyz"
-            )
-            raise together.InstanceError(model=args.model)
-        else:
-            logger.critical(f"Error raised: {response['error']}")
 
     else:
-        logger.critical("Unknown response received")
-        raise together.ResponseError("Unknown response received. Please try again.")
+        if "output" in response.keys():
+            if "choices" in dict(response["output"]).keys():
+                text = str(response["output"]["choices"][0]["text"])
+                print(text.strip())
+            elif "error" in dict(response["output"]).keys():
+                raise together.ResponseError(response["output"]["error"])
+            else:
+                raise together.ResponseError(
+                    f"Unknown error occured. Received unhandled response: {response}"
+                )
+
+        elif "error" in response.keys():
+            if response["error"] == "Returned error: no instance":
+                message = f"No running instances for {args.model}. You can start an instance by navigating to the Together Playground at api.together.xyz"
+                raise together.InstanceError(model=args.model, message=message)
+            else:
+                raise together.ResponseError(
+                    message=f"Error raised: {response['error']}"
+                )
 
-    print(text.strip())
+        else:
+            raise together.ResponseError("Unknown response received. Please try again.")
 
 
 def _run_complete(args: argparse.Namespace) -> None:
-    logger = get_logger(__name__, log_level=args.log)
-
     complete = Complete()
 
     if args.no_stream:
@@ -153,7 +142,7 @@ def _run_complete(args: argparse.Namespace) -> None:
             repetition_penalty=args.repetition_penalty,
             logprobs=args.logprobs,
         )
-        no_streamer(args, response, logger)
+        no_streamer(args, response)
     else:
         for text in complete.create_streaming(
             prompt=args.prompt,
@@ -164,6 +153,11 @@ def _run_complete(args: argparse.Namespace) -> None:
             top_p=args.top_p,
             top_k=args.top_k,
             repetition_penalty=args.repetition_penalty,
+            raw=args.raw,
         ):
-            print(text, end="", flush=True)
-        print("\n")
+            if not args.raw:
+                print(text, end="", flush=True)
+            else:
+                print(text)
+        if not args.raw:
+            print("\n")

together/commands/files.py

@@ -4,7 +4,7 @@ import argparse
 import json
 
 from together import Files
-from together.utils.utils import extract_time
+from together.utils import extract_time
 
 
 def add_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
@@ -34,15 +34,6 @@ def _add_check(parser: argparse._SubParsersAction[argparse.ArgumentParser]) -> N
         help="Local file to upload",
         type=str,
     )
-    subparser.add_argument(
-        "--model",
-        "-m",
-        default=None,
-        metavar="MODELNAME",
-        help="check data for this model's special tokens",
-        type=str,
-        required=False,
-    )
     subparser.set_defaults(func=_run_check)
 
 
@@ -118,37 +109,31 @@ def _add_retrieve_content(
 
 
 def _run_list(args: argparse.Namespace) -> None:
-    files = Files()
-    response = files.list()
+    response = Files.list()
     response["data"].sort(key=extract_time)
     print(json.dumps(response, indent=4))
 
 
 def _run_check(args: argparse.Namespace) -> None:
-    files = Files()
-    response = files.check(args.file, args.model)
+    response = Files.check(args.file)
     print(json.dumps(response, indent=4))
 
 
 def _run_upload(args: argparse.Namespace) -> None:
-    files = Files()
-    response = files.upload(file=args.file, check=not args.no_check, model=args.model)
+    response = Files.upload(file=args.file, check=not args.no_check, model=args.model)
     print(json.dumps(response, indent=4))
 
 
 def _run_delete(args: argparse.Namespace) -> None:
-    files = Files()
-    response = files.delete(args.file_id)
+    response = Files.delete(args.file_id)
     print(json.dumps(response, indent=4))
 
 
 def _run_retrieve(args: argparse.Namespace) -> None:
-    files = Files()
-    response = files.retrieve(args.file_id)
+    response = Files.retrieve(args.file_id)
     print(json.dumps(response, indent=4))
 
 
 def _run_retrieve_content(args: argparse.Namespace) -> None:
-    files = Files()
-    output = files.retrieve_content(args.file_id, args.output)
+    output = Files.retrieve_content(args.file_id, args.output)
     print(output)

together/commands/finetune.py

@@ -5,7 +5,7 @@ import json
 import os
 
 from together import Finetune
-from together.utils.utils import parse_timestamp
+from together.utils import parse_timestamp
 
 
 def add_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
@@ -153,6 +153,12 @@ def _add_create(parser: argparse._SubParsersAction[argparse.ArgumentParser]) ->
         help="Do not report metrics to wandb.ai.",
         action="store_true",
     )
+    subparser.add_argument(
+        "--quiet",
+        default=False,
+        action="store_true",
+        help="Indicates whether to disable checking",
+    )
 
     subparser.set_defaults(func=_run_create)
 
@@ -309,14 +315,14 @@ def _run_create(args: argparse.Namespace) -> None:
         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,
     )
 
     print(json.dumps(response, indent=4))
 
 
 def _run_list(args: argparse.Namespace) -> None:
-    finetune = Finetune()
-    response = finetune.list()
+    response = Finetune.list()
     data_list = response["data"]
     sorted_data = sorted(data_list, key=lambda x: parse_timestamp(x["created_at"]))
     response["data"] = sorted_data
@@ -324,38 +330,32 @@ def _run_list(args: argparse.Namespace) -> None:
 
 
 def _run_retrieve(args: argparse.Namespace) -> None:
-    finetune = Finetune()
-    response = finetune.retrieve(args.fine_tune_id)
+    response = Finetune.retrieve(args.fine_tune_id)
     print(json.dumps(response, indent=4))
 
 
 def _run_cancel(args: argparse.Namespace) -> None:
-    finetune = Finetune()
-    response = finetune.cancel(args.fine_tune_id)
+    response = Finetune.cancel(args.fine_tune_id)
     print(json.dumps(response, indent=4))
 
 
 def _run_list_events(args: argparse.Namespace) -> None:
-    finetune = Finetune()
-    response = finetune.list_events(args.fine_tune_id)
+    response = Finetune.list_events(args.fine_tune_id)
     print(json.dumps(response, indent=4))
 
 
 def _run_download(args: argparse.Namespace) -> None:
-    finetune = Finetune()
-    response = finetune.download(args.fine_tune_id, args.output, args.checkpoint_step)
+    response = Finetune.download(args.fine_tune_id, args.output, args.checkpoint_step)
     print(response)
 
 
 def _run_status(args: argparse.Namespace) -> None:
-    finetune = Finetune()
-    response = finetune.get_job_status(args.fine_tune_id)
+    response = Finetune.get_job_status(args.fine_tune_id)
     print(response)
 
 
 def _run_checkpoint(args: argparse.Namespace) -> None:
-    finetune = Finetune()
-    checkpoints = finetune.get_checkpoints(args.fine_tune_id)
+    checkpoints = Finetune.get_checkpoints(args.fine_tune_id)
     print(json.dumps(checkpoints, indent=4))
     print(f"\n{len(checkpoints)} checkpoints found")
 

together/commands/image.py

@@ -3,13 +3,15 @@ from __future__ import annotations
 import argparse
 import base64
 import json
-import logging
 import sys
 from typing import Any, Dict
 
 import together
 from together import Image
-from together.utils.utils import get_logger
+from together.utils import get_logger
+
+
+logger = get_logger(str(__name__))
 
 
 def add_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
@@ -89,9 +91,7 @@ def add_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser])
     subparser.set_defaults(func=_run_complete)
 
 
-def _save_image(
-    args: argparse.Namespace, response: Dict[str, Any], logger: logging.Logger
-) -> None:
+def _save_image(args: argparse.Namespace, response: Dict[str, Any]) -> None:
     if args.raw:
         print(json.dumps(response, indent=4))
         sys.exit()
@@ -123,8 +123,6 @@ def _save_image(
 
 
 def _run_complete(args: argparse.Namespace) -> None:
-    logger = get_logger(__name__, log_level=args.log)
-
     complete = Image()
 
     response = complete.create(
@@ -138,4 +136,4 @@ def _run_complete(args: argparse.Namespace) -> None:
         negative_prompt=args.negative_prompt,
     )
 
-    _save_image(args, response, logger)
+    _save_image(args, response)

together/commands/models.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import argparse
 import json
 
-from together import Models
+import together
 
 
 def add_parser(
@@ -107,8 +107,7 @@ def _add_ready(
 
 
 def _run_list(args: argparse.Namespace) -> None:
-    models = Models()
-    response = models.list()
+    response = together.Models.list()
     if args.raw:
         print(json.dumps(response, indent=4))
     else:
@@ -119,35 +118,29 @@ def _run_list(args: argparse.Namespace) -> None:
 
 
 def _run_info(args: argparse.Namespace) -> None:
-    models = Models()
-    response = models.list()
-
-    # list of keys to display by default from models info dict
-    visible_keys = [
-        "name",
-        "display_name",
-        "display_type",
-        "description",
-        "creator_organization",
-        "hardware_label",
-        "pricing_tier",
-        "config",
-        "base",
-    ]
-
-    for i in response:
-        if i["name"] == args.model:
-            if args.raw:
-                print(json.dumps(i, indent=4))
-            else:
-                model_info = {key: i[key] for key in visible_keys if key in i}
-                print(json.dumps(model_info, indent=4))
-            break
+    if not args.raw:
+        hidden_keys = [
+            "_id",
+            "modelInstanceConfig",
+            "created_at",
+            "update_at",
+            "pricing",
+            "show_in_playground",
+            "access",
+            "pricing_tier",
+            "hardware_label",
+            "depth",
+        ]
+    else:
+        hidden_keys = []
+
+    model_info = together.Models.info(args.model, hidden_keys=hidden_keys)
+
+    print(json.dumps(model_info, indent=4))
 
 
 def _run_instances(args: argparse.Namespace) -> None:
-    models = Models()
-    response = models.instances()
+    response = together.Models.instances()
     if args.raw:
         print(json.dumps(response, indent=4))
     else:
@@ -156,18 +149,15 @@ def _run_instances(args: argparse.Namespace) -> None:
 
 
 def _run_start(args: argparse.Namespace) -> None:
-    models = Models()
-    response = models.start(args.model)
+    response = together.Models.start(args.model)
     print(json.dumps(response, indent=4))
 
 
 def _run_stop(args: argparse.Namespace) -> None:
-    models = Models()
-    response = models.stop(args.model)
+    response = together.Models.stop(args.model)
     print(json.dumps(response, indent=4))
 
 
 def _run_ready(args: argparse.Namespace) -> None:
-    models = Models()
-    response = models.ready(args.model)
+    response = together.Models.ready(args.model)
     print(json.dumps(response, indent=4))

together/complete.py

@@ -1,22 +1,14 @@
 import json
 from typing import Any, Dict, Iterator, List, Optional
 
-import requests
-import sseclient  # type: ignore
-
 import together
-from together.utils.utils import get_logger, verify_api_key
+from together.utils import create_post_request, get_logger, sse_client
 
 
-logger = get_logger(str(__name__), log_level=together.log_level)
+logger = get_logger(str(__name__))
 
 
 class Complete:
-    def __init__(
-        self,
-    ) -> None:
-        verify_api_key(logger)
-
     @classmethod
     def create(
         self,
@@ -45,46 +37,16 @@ class Complete:
             "logprobs": logprobs,
         }
 
-        # HTTP headers for authorization
-        headers = {
-            "Authorization": f"Bearer {together.api_key}",
-            "Content-Type": "application/json",
-            "User-Agent": together.user_agent,
-        }
-
         # send request
-        try:
-            response = requests.post(
-                together.api_base_complete,
-                headers=headers,
-                json=parameter_payload,
-            )
-        except requests.exceptions.RequestException as e:
-            logger.critical(f"Response error raised: {e}")
-            raise together.ResponseError(e)
-
-        if response.status_code == 429:
-            logger.critical(
-                f"""No running instances for {model}.
-                You can start an instance with one of the following methods:
-                  1. navigating to the Together Playground at api.together.ai
-                  2. starting one in python using together.Models.start(model_name)
-                  3. `$ together models start <MODEL_NAME>` at the command line.
-                See `together.Models.list()` in python or `$ together models list` in command line
-                to get an updated list of valid model names.
-                """
-            )
-            raise together.InstanceError(model=model)
-
-        response.raise_for_status()
-
+        response = create_post_request(
+            url=together.api_base_complete, json=parameter_payload
+        )
+        if not response:
+            return {}
         try:
             response_json = dict(response.json())
 
         except Exception as e:
-            logger.critical(
-                f"Error raised: {e}\nResponse status code = {response.status_code}"
-            )
             raise together.JSONError(e, http_status=response.status_code)
         return response_json
 
@@ -99,6 +61,7 @@ class Complete:
         top_p: Optional[float] = 0.7,
         top_k: Optional[int] = 50,
         repetition_penalty: Optional[float] = None,
+        raw: Optional[bool] = False,
     ) -> Iterator[str]:
         """
         Prints streaming responses and returns the completed text.
@@ -118,48 +81,30 @@ class Complete:
             "repetition_penalty": repetition_penalty,
             "stream_tokens": True,
         }
-        # HTTP headers for authorization
-        headers = {
-            "Authorization": f"Bearer {together.api_key}",
-            "Content-Type": "application/json",
-            "User-Agent": together.user_agent,
-        }
 
         # send request
-        try:
-            response = requests.post(
-                together.api_base_complete,
-                headers=headers,
-                json=parameter_payload,
-                stream=True,
-            )
-        except requests.exceptions.RequestException as e:
-            logger.critical(f"Response error raised: {e}")
-            raise together.ResponseError(e)
-
-        if response.status_code == 200:
-            output = ""
-            client = sseclient.SSEClient(response)
-            for event in client.events():
-                if event.data != "[DONE]":
-                    text = json.loads(event.data)["choices"][0]["text"]
+        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():
+            if raw:
+                yield str(event.data)
+            elif event.data != "[DONE]":
+                json_response = dict(json.loads(event.data))
+                if "error" in json_response.keys():
+                    raise together.ResponseError(
+                        json_response["error"]["error"],
+                        request_id=json_response["error"]["request_id"],
+                    )
+                elif "choices" in json_response.keys():
+                    text = json_response["choices"][0]["text"]
                     output += text
                     yield text
-        elif response.status_code == 429:
-            logger.critical(
-                f"""No running instances for {model}.
-                You can start an instance with one of the following methods:
-                  1. navigating to the Together Playground at api.together.ai
-                  2. starting one in python using together.Models.start(model_name)
-                  3. `$ together models start <MODEL_NAME>` at the command line.
-                See `together.Models.list()` in python or `$ together models list` in command line
-                to get an updated list of valid model names.
-                """
-            )
-            raise together.InstanceError(model=model)
-        else:
-            logger.critical(
-                f"Unknown error raised.\nResponse status code = {response.status_code}"
-            )
-            response.raise_for_status()
-            raise together.ResponseError(http_status=response.status_code)
+                else:
+                    raise together.ResponseError(
+                        f"Unknown error occured. Received unhandled response: {event.data}"
+                    )