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

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 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}"
+                    )

together/error.py

@@ -11,6 +11,7 @@ class TogetherException(Exception):
         http_status: Optional[int] = None,
         json_body: Optional[Any] = None,
         headers: Optional[Union[str, Dict[Any, Any]]] = None,
+        request_id: Optional[str] = "",
     ) -> None:
         super(TogetherException, self).__init__(message)
 
@@ -28,12 +29,14 @@ class TogetherException(Exception):
         self.http_status = http_status
         self.json_body = json_body
         self.headers = headers or {}
+        self.request_id = request_id
 
     def __repr__(self) -> str:
-        return "%s(message=%r, http_status=%r)" % (
+        return "%s(message=%r, http_status=%r, request_id=%r)" % (
             self.__class__.__name__,
             self._message,
             self.http_status,
+            self.request_id,
         )
 
 
@@ -59,7 +62,14 @@ class InstanceError(TogetherException):
         headers: Optional[str] = None,
         model: Optional[str] = "model",
     ) -> None:
-        message = f"No running instances for {model}. You can start an instance by navigating to the Together Playground at api.together.ai"
+        message = 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.
+                """
         super(InstanceError, self).__init__(
             message, http_body, http_status, json_body, headers
         )

together/files.py

@@ -2,58 +2,41 @@ import json
 import os
 import posixpath
 import urllib.parse
-from typing import Any, Dict, List, Mapping, Optional, Union, cast
+from typing import Any, Dict, List, Mapping, Optional, Union
 
 import requests
 from tqdm import tqdm
 from tqdm.utils import CallbackIOWrapper
 
 import together
-from together import get_logger, verify_api_key
+from together.utils import (
+    create_get_request,
+    get_logger,
+    response_to_dict,
+)
 
 
-logger = get_logger(str(__name__), log_level=together.log_level)
-
 # the number of bytes in a gigabyte, used to convert bytes to GB for readable comparison
 NUM_BYTES_IN_GB = 2**30
 
 # maximum number of GB sized files we support finetuning for
 MAX_FT_GB = 4.9
 
+logger = get_logger(str(__name__))
 
-class Files:
-    def __init__(
-        self,
-    ) -> None:
-        verify_api_key(logger)
 
+class Files:
     @classmethod
     def list(self) -> Dict[str, List[Dict[str, Union[str, int]]]]:
-        headers = {
-            "Authorization": f"Bearer {together.api_key}",
-            "User-Agent": together.user_agent,
-        }
-
         # send request
-        try:
-            response = requests.get(together.api_base_files, headers=headers)
-            response.raise_for_status()
-        except requests.exceptions.RequestException as e:
-            logger.critical(f"Response error raised: {e}")
-            raise together.ResponseError(e)
-        try:
-            response_json = dict(response.json())
-        except Exception as e:
-            logger.critical(
-                f"JSON Error raised: {e}\nResponse status code = {response.status_code}"
-            )
-            raise together.JSONError(e, http_status=response.status_code)
-
-        return response_json
+        response = create_get_request(together.api_base_files)
+        if not response:
+            return {}
+        return response_to_dict(response)
 
     @classmethod
-    def check(self, file: str, model: Optional[str] = None) -> Dict[str, object]:
-        return check_json(file, model)
+    def check(self, file: str) -> Dict[str, object]:
+        return check_json(file)
 
     @classmethod
     def upload(
@@ -70,10 +53,11 @@ class Files:
         }
 
         if check:
-            report_dict = check_json(file, model)
+            report_dict = check_json(file)
             if not report_dict["is_check_passed"]:
-                print(report_dict)
-                raise together.FileTypeError("Invalid file supplied. Failed to upload.")
+                raise together.FileTypeError(
+                    f"Invalid file supplied. Failed to upload.\nReport:\n {report_dict}"
+                )
         else:
             report_dict = {}
 
@@ -116,7 +100,7 @@ class Files:
             file_id = response.headers["X-Together-File-Id"]
 
             logger.info(f"R2 Signed URL: {r2_signed_url}")
-            logger.info("File-ID")
+            logger.info(f"File-ID: {file_id}")
 
             logger.info("Uploading file...")
 
@@ -177,44 +161,16 @@ class Files:
             logger.critical(f"Response error raised: {e}")
             raise together.ResponseError(e)
 
-        try:
-            response_json = dict(response.json())
-        except Exception as e:
-            logger.critical(
-                f"JSON Error raised: {e}\nResponse status code = {response.status_code}"
-            )
-            raise together.JSONError(e, http_status=response.status_code)
-
-        return response_json
+        return response_to_dict(response)
 
     @classmethod
     def retrieve(self, file_id: str) -> Dict[str, Union[str, int]]:
         retrieve_url = urllib.parse.urljoin(together.api_base_files, file_id)
-
         logger.info(f"Retrieve URL: {retrieve_url}")
-
-        headers = {
-            "Authorization": f"Bearer {together.api_key}",
-            "User-Agent": together.user_agent,
-        }
-
-        # send request
-        try:
-            response = requests.get(retrieve_url, headers=headers)
-            response.raise_for_status()
-        except requests.exceptions.RequestException as e:
-            logger.critical(f"Response error raised: {e}")
-            raise together.ResponseError(e)
-
-        try:
-            response_json = dict(response.json())
-        except Exception as e:
-            logger.critical(
-                f"JSON Error raised: {e}\nResponse status code = {response.status_code}"
-            )
-            raise together.JSONError(e, http_status=response.status_code)
-
-        return response_json
+        response = create_get_request(retrieve_url)
+        if not response:
+            return {}
+        return response_to_dict(response)
 
     @classmethod
     def retrieve_content(self, file_id: str, output: Union[str, None] = None) -> str:
@@ -288,23 +244,11 @@ class Files:
 
 def check_json(
     file: str,
-    model: Optional[str] = None,
 ) -> Dict[str, object]:
     report_dict = {
         "is_check_passed": True,
         "model_special_tokens": "we are not yet checking end of sentence tokens for this model",
     }
-    num_samples_w_eos_token = 0
-
-    model_info_dict = cast(Dict[str, Any], together.model_info_dict)
-
-    eos_token = None
-    if model is not None and model in model_info_dict:
-        if "eos_token" in model_info_dict[model]:
-            eos_token = model_info_dict[model]["eos_token"]
-            report_dict[
-                "model_special_tokens"
-            ] = f"the end of sentence token for this model is {eos_token}"
 
     if not os.path.isfile(file):
         report_dict["file_present"] = f"File not found at given file path {file}"
@@ -358,10 +302,6 @@ def check_json(
 
                         report_dict["is_check_passed"] = False
 
-                    elif eos_token:
-                        if eos_token in json_line["text"]:
-                            num_samples_w_eos_token += 1
-
             # make sure this is outside the for idx, line in enumerate(f): for loop
             if idx + 1 < together.min_samples:
                 report_dict["min_samples"] = (
@@ -383,6 +323,4 @@ def check_json(
             )
             report_dict["is_check_passed"] = False
 
-    report_dict["num_samples_w_eos_token"] = num_samples_w_eos_token
-
     return report_dict