formats by Black

Author: ted-at-openai

openai/__init__.py

@@ -32,8 +32,9 @@
 organization = os.environ.get("OPENAI_ORGANIZATION")
 api_base = os.environ.get("OPENAI_API_BASE", "https://api.openai.com/v1")
 api_type = os.environ.get("OPENAI_API_TYPE", "open_ai")
-api_version = "2022-03-01-preview" if api_type in (
-    "azure", "azure_ad", "azuread") else None
+api_version = (
+    "2022-03-01-preview" if api_type in ("azure", "azure_ad", "azuread") else None
+)
 verify_ssl_certs = True  # No effect. Certificates are always verified.
 proxy = None
 app_info = None

openai/api_resources/abstract/api_resource.py

@@ -62,24 +62,23 @@ def instance_url(self, operation=None):
                     self.azure_api_prefix,
                     base,
                     extn,
-                    api_version
+                    api_version,
                 )
 
             return "/%s/%s/%s/%s?api-version=%s" % (
                 self.azure_api_prefix,
                 self.azure_deployments_prefix,
                 extn,
                 operation,
-                api_version
+                api_version,
             )
 
         elif self.typed_api_type == ApiType.OPEN_AI:
             base = self.class_url()
             return "%s/%s" % (base, extn)
 
         else:
-            raise error.InvalidAPIType(
-                "Unsupported API type %s" % self.api_type)
+            raise error.InvalidAPIType("Unsupported API type %s" % self.api_type)
 
     # The `method_` and `url_` arguments are suffixed with an underscore to
     # avoid conflicting with actual request parameters in `params`.
@@ -101,7 +100,7 @@ def _static_request(
             api_version=api_version,
             organization=organization,
             api_base=api_base,
-            api_type=api_type
+            api_type=api_type,
         )
         response, _, api_key = requestor.request(
             method_, url_, params, request_id=request_id
@@ -111,8 +110,13 @@ def _static_request(
         )
 
     @classmethod
-    def _get_api_type_and_version(cls, api_type: Optional[str] = None, api_version: Optional[str] = None):
-        typed_api_type = ApiType.from_str(
-            api_type) if api_type else ApiType.from_str(openai.api_type)
+    def _get_api_type_and_version(
+        cls, api_type: Optional[str] = None, api_version: Optional[str] = None
+    ):
+        typed_api_type = (
+            ApiType.from_str(api_type)
+            if api_type
+            else ApiType.from_str(openai.api_type)
+        )
         typed_api_version = api_version or openai.api_version
         return (typed_api_type, typed_api_version)

openai/api_resources/abstract/createable_api_resource.py

@@ -25,16 +25,16 @@ def create(
             organization=organization,
         )
         typed_api_type, api_version = cls._get_api_type_and_version(
-            api_type, api_version)
+            api_type, api_version
+        )
 
         if typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD):
             base = cls.class_url()
-            url = "/%s%s?api-version=%s" % (cls.azure_api_prefix,
-                                            base, api_version)
+            url = "/%s%s?api-version=%s" % (cls.azure_api_prefix, base, api_version)
         elif typed_api_type == ApiType.OPEN_AI:
             url = cls.class_url()
         else:
-            raise error.InvalidAPIType('Unsupported API type %s' % api_type)
+            raise error.InvalidAPIType("Unsupported API type %s" % api_type)
 
         response, _, api_key = requestor.request(
             "post", url, params, request_id=request_id

openai/api_resources/abstract/deletable_api_resource.py

@@ -9,20 +9,26 @@ class DeletableAPIResource(APIResource):
     @classmethod
     def delete(cls, sid, api_type=None, api_version=None, **params):
         if isinstance(cls, APIResource):
-            raise ValueError(
-                ".delete may only be called as a class method now.")
+            raise ValueError(".delete may only be called as a class method now.")
 
         base = cls.class_url()
         extn = quote_plus(sid)
 
         typed_api_type, api_version = cls._get_api_type_and_version(
-            api_type, api_version)
+            api_type, api_version
+        )
         if typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD):
             url = "/%s%s/%s?api-version=%s" % (
-                cls.azure_api_prefix, base, extn, api_version)
+                cls.azure_api_prefix,
+                base,
+                extn,
+                api_version,
+            )
         elif typed_api_type == ApiType.OPEN_AI:
             url = "%s/%s" % (base, extn)
         else:
-            raise error.InvalidAPIType('Unsupported API type %s' % api_type)
+            raise error.InvalidAPIType("Unsupported API type %s" % api_type)
 
-        return cls._static_request("delete", url, api_type=api_type, api_version=api_version, **params)
+        return cls._static_request(
+            "delete", url, api_type=api_type, api_version=api_version, **params
+        )

openai/api_resources/abstract/engine_api_resource.py

@@ -29,7 +29,8 @@ def class_url(
         # with forward slashes (/), so replace the former with the latter.
         base = cls.OBJECT_NAME.replace(".", "/")  # type: ignore
         typed_api_type, api_version = cls._get_api_type_and_version(
-            api_type, api_version)
+            api_type, api_version
+        )
 
         if typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD):
             if not api_version:
@@ -46,7 +47,7 @@ def class_url(
                 cls.azure_deployments_prefix,
                 extn,
                 base,
-                api_version
+                api_version,
             )
 
         elif typed_api_type == ApiType.OPEN_AI:
@@ -81,12 +82,16 @@ def create(
         if typed_api_type in (util.ApiType.AZURE, util.ApiType.AZURE_AD):
             if deployment_id is None and engine is None:
                 raise error.InvalidRequestError(
-                    "Must provide an 'engine' or 'deployment_id' parameter to create a %s" % cls, "engine"
+                    "Must provide an 'engine' or 'deployment_id' parameter to create a %s"
+                    % cls,
+                    "engine",
                 )
         else:
             if model is None and engine is None:
                 raise error.InvalidRequestError(
-                    "Must provide an 'engine' or 'model' parameter to create a %s" % cls, "engine"
+                    "Must provide an 'engine' or 'model' parameter to create a %s"
+                    % cls,
+                    "engine",
                 )
 
         if timeout is None:
@@ -155,7 +160,7 @@ def instance_url(self):
             )
 
         extn = quote_plus(id)
-        params_connector = '?'
+        params_connector = "?"
 
         if self.typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD):
             api_version = self.api_version or openai.api_version
@@ -170,17 +175,16 @@ def instance_url(self):
                 self.engine,
                 base,
                 extn,
-                api_version
+                api_version,
             )
-            params_connector = '&'
+            params_connector = "&"
 
         elif self.typed_api_type == ApiType.OPEN_AI:
             base = self.class_url(self.engine, self.api_type, self.api_version)
             url = "%s/%s" % (base, extn)
 
         else:
-            raise error.InvalidAPIType(
-                "Unsupported API type %s" % self.api_type)
+            raise error.InvalidAPIType("Unsupported API type %s" % self.api_type)
 
         timeout = self.get("timeout")
         if timeout is not None:

openai/api_resources/abstract/listable_api_resource.py

@@ -28,16 +28,16 @@ def list(
         )
 
         typed_api_type, api_version = cls._get_api_type_and_version(
-            api_type, api_version)
+            api_type, api_version
+        )
 
         if typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD):
             base = cls.class_url()
-            url = "/%s%s?api-version=%s" % (cls.azure_api_prefix,
-                                            base, api_version)
+            url = "/%s%s?api-version=%s" % (cls.azure_api_prefix, base, api_version)
         elif typed_api_type == ApiType.OPEN_AI:
             url = cls.class_url()
         else:
-            raise error.InvalidAPIType('Unsupported API type %s' % api_type)
+            raise error.InvalidAPIType("Unsupported API type %s" % api_type)
 
         response, _, api_key = requestor.request(
             "get", url, params, request_id=request_id

openai/api_resources/deployment.py

@@ -1,5 +1,9 @@
 from openai import util
-from openai.api_resources.abstract import DeletableAPIResource, ListableAPIResource, CreateableAPIResource
+from openai.api_resources.abstract import (
+    DeletableAPIResource,
+    ListableAPIResource,
+    CreateableAPIResource,
+)
 from openai.error import InvalidRequestError, APIError
 
 
@@ -12,10 +16,12 @@ def create(cls, *args, **kwargs):
         Creates a new deployment for the provided prompt and parameters.
         """
         typed_api_type, _ = cls._get_api_type_and_version(
-            kwargs.get("api_type", None), None)
+            kwargs.get("api_type", None), None
+        )
         if typed_api_type not in (util.ApiType.AZURE, util.ApiType.AZURE_AD):
             raise APIError(
-                "Deployment operations are only available for the Azure API type.")
+                "Deployment operations are only available for the Azure API type."
+            )
 
         if kwargs.get("model", None) is None:
             raise InvalidRequestError(
@@ -30,8 +36,10 @@ def create(cls, *args, **kwargs):
                 param="scale_settings",
             )
 
-        if "scale_type" not in scale_settings or \
-                (scale_settings["scale_type"].lower() == 'manual' and "capacity" not in scale_settings):
+        if "scale_type" not in scale_settings or (
+            scale_settings["scale_type"].lower() == "manual"
+            and "capacity" not in scale_settings
+        ):
             raise InvalidRequestError(
                 "The 'scale_settings' parameter contains invalid or incomplete values.",
                 param="scale_settings",
@@ -42,29 +50,35 @@ def create(cls, *args, **kwargs):
     @classmethod
     def list(cls, *args, **kwargs):
         typed_api_type, _ = cls._get_api_type_and_version(
-            kwargs.get("api_type", None), None)
+            kwargs.get("api_type", None), None
+        )
         if typed_api_type not in (util.ApiType.AZURE, util.ApiType.AZURE_AD):
             raise APIError(
-                "Deployment operations are only available for the Azure API type.")
+                "Deployment operations are only available for the Azure API type."
+            )
 
         return super().list(*args, **kwargs)
 
     @classmethod
     def delete(cls, *args, **kwargs):
         typed_api_type, _ = cls._get_api_type_and_version(
-            kwargs.get("api_type", None), None)
+            kwargs.get("api_type", None), None
+        )
         if typed_api_type not in (util.ApiType.AZURE, util.ApiType.AZURE_AD):
             raise APIError(
-                "Deployment operations are only available for the Azure API type.")
+                "Deployment operations are only available for the Azure API type."
+            )
 
         return super().delete(*args, **kwargs)
 
     @classmethod
     def retrieve(cls, *args, **kwargs):
         typed_api_type, _ = cls._get_api_type_and_version(
-            kwargs.get("api_type", None), None)
+            kwargs.get("api_type", None), None
+        )
         if typed_api_type not in (util.ApiType.AZURE, util.ApiType.AZURE_AD):
             raise APIError(
-                "Deployment operations are only available for the Azure API type.")
+                "Deployment operations are only available for the Azure API type."
+            )
 
         return super().retrieve(*args, **kwargs)

openai/api_resources/edit.py

@@ -20,7 +20,8 @@ def create(cls, *args, **kwargs):
         typed_api_type = cls._get_api_type_and_version(api_type=api_type)[0]
         if typed_api_type in (util.ApiType.AZURE, util.ApiType.AZURE_AD):
             raise error.InvalidAPIType(
-                "This operation is not supported by the Azure OpenAI API yet.")
+                "This operation is not supported by the Azure OpenAI API yet."
+            )
 
         while True:
             try:

openai/api_resources/file.py

@@ -25,8 +25,7 @@ def create(
         user_provided_filename=None,
     ):
         if purpose != "search" and model is not None:
-            raise ValueError(
-                "'model' is only meaningful if 'purpose' is 'search'")
+            raise ValueError("'model' is only meaningful if 'purpose' is 'search'")
         requestor = api_requestor.APIRequestor(
             api_key,
             api_base=api_base or openai.api_base,
@@ -35,16 +34,16 @@ def create(
             organization=organization,
         )
         typed_api_type, api_version = cls._get_api_type_and_version(
-            api_type, api_version)
+            api_type, api_version
+        )
 
         if typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD):
             base = cls.class_url()
-            url = "/%s%s?api-version=%s" % (cls.azure_api_prefix,
-                                            base, api_version)
+            url = "/%s%s?api-version=%s" % (cls.azure_api_prefix, base, api_version)
         elif typed_api_type == ApiType.OPEN_AI:
             url = cls.class_url()
         else:
-            raise error.InvalidAPIType('Unsupported API type %s' % api_type)
+            raise error.InvalidAPIType("Unsupported API type %s" % api_type)
 
         # Set the filename on 'purpose' and 'model' to None so they are
         # interpreted as form data.
@@ -53,9 +52,10 @@ def create(
             files.append(("model", (None, model)))
         if user_provided_filename is not None:
             files.append(
-                ("file", (user_provided_filename, file, 'application/octet-stream')))
+                ("file", (user_provided_filename, file, "application/octet-stream"))
+            )
         else:
-            files.append(("file", ("file", file, 'application/octet-stream')))
+            files.append(("file", ("file", file, "application/octet-stream")))
         response, _, api_key = requestor.request("post", url, files=files)
         return util.convert_to_openai_object(
             response, api_key, api_version, organization
@@ -69,7 +69,7 @@ def download(
         api_base=None,
         api_type=None,
         api_version=None,
-        organization=None
+        organization=None,
     ):
         requestor = api_requestor.APIRequestor(
             api_key,
@@ -79,16 +79,21 @@ def download(
             organization=organization,
         )
         typed_api_type, api_version = cls._get_api_type_and_version(
-            api_type, api_version)
+            api_type, api_version
+        )
 
         if typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD):
             base = cls.class_url()
             url = "/%s%s/%s/content?api-version=%s" % (
-                cls.azure_api_prefix, base, id, api_version)
+                cls.azure_api_prefix,
+                base,
+                id,
+                api_version,
+            )
         elif typed_api_type == ApiType.OPEN_AI:
             url = f"{cls.class_url()}/{id}/content"
         else:
-            raise error.InvalidAPIType('Unsupported API type %s' % api_type)
+            raise error.InvalidAPIType("Unsupported API type %s" % api_type)
 
         result = requestor.request_raw("get", url)
         if not 200 <= result.status_code < 300: