Add Azure AD authentication support (#92)

* Add Azure AD authentication support

* Add azure_ad code examples

* Remove debug print statement

* Bump version

Author: t-asutedjo

README.md

@@ -65,13 +65,13 @@ openai.api_base = "https://example-endpoint.openai.azure.com"
 openai.api_version = "2021-11-01-preview"
 
 # create a completion
-completion = openai.Completion.create(engine="deployment-namme", prompt="Hello world")
+completion = openai.Completion.create(engine="deployment-name", prompt="Hello world")
 
 # print the completion
 print(completion.choices[0].text)
 
 # create a search and pass the deployment-name as the engine Id.
-search = openai.Engine(id="deployment-namme").search(documents=["White House", "hospital", "school"], query ="the president")
+search = openai.Engine(id="deployment-name").search(documents=["White House", "hospital", "school"], query ="the president")
 
 # print the search
 print(search)
@@ -81,6 +81,27 @@ Please note that for the moment, the Microsoft Azure endpoints can only be used
 For a detailed example on how to use fine-tuning and other operations using Azure endpoints, please check out the following Jupyter notebook:
 [Using Azure fine-tuning](https://github.com/openai/openai-python/blob/main/examples/azure/finetuning.ipynb)
 
+### Microsoft Azure Active Directory Authentication
+
+In order to use Microsoft Active Directory to authenticate to your Azure endpoint, you need to set the api_type to "azure_ad" and pass the acquired credential token to api_key. The rest of the parameters need to be set as specified in the previous section.
+
+
+```python
+from azure.identity import DefaultAzureCredential
+import openai
+
+# Request credential
+default_credential = DefaultAzureCredential()
+token = default_credential.get_token("https://cognitiveservices.azure.com")
+
+# Setup parameters
+openai.api_type = "azure_ad"
+openai.api_key = token.token
+openai.api_base = "https://example-endpoint.openai.azure.com/"
+openai.api_version = "2022-03-01-preview"
+
+# ...
+```
 ### Command-line interface
 
 This library additionally provides an `openai` command-line utility

examples/azure/finetuning.ipynb

@@ -40,6 +40,35 @@
     "openai.api_version = '2022-03-01-preview' # this may change in the future"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Microsoft Active Directory Authentication\n",
+    "Instead of key based authentication, you can use Active Directory to authenticate using credential tokens. Uncomment the next code section to use credential based authentication:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"\n",
+    "from azure.identity import DefaultAzureCredential\n",
+    "\n",
+    "default_credential = DefaultAzureCredential()\n",
+    "token = default_credential.get_token(\"https://cognitiveservices.azure.com\")\n",
+    "\n",
+    "openai.api_type = 'azure_ad'\n",
+    "openai.api_key = token.token\n",
+    "openai.api_version = '2022-03-01-preview' # this may change in the future\n",
+    "\n",
+    "\n",
+    "openai.api_base = '' # Please add your endpoint here\n",
+    "\"\"\""
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -418,10 +447,10 @@
  ],
  "metadata": {
   "interpreter": {
-   "hash": "1efaa68c6557ae864f04a55d1c611eb06843d0ca160c97bf33f135c19475264d"
+   "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
   },
   "kernelspec": {
-   "display_name": "Python 3.8.10 ('openai-env')",
+   "display_name": "Python 3.8.10 64-bit",
    "language": "python",
    "name": "python3"
   },

openai/__init__.py

@@ -32,7 +32,8 @@
 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 == "azure" 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

@@ -49,12 +49,12 @@ def instance_url(self, operation=None):
         api_version = self.api_version or openai.api_version
         extn = quote_plus(id)
 
-        if self.typed_api_type == ApiType.AZURE:
+        if self.typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD):
             if not api_version:
                 raise error.InvalidRequestError(
                     "An API version is required for the Azure API type."
                 )
-            
+
             if not operation:
                 base = self.class_url()
                 return "/%s%s/%s?api-version=%s" % (
@@ -72,13 +72,13 @@ def instance_url(self, operation=None):
                 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`.
@@ -111,7 +111,7 @@ def _static_request(
 
     @classmethod
     def _get_api_type_and_version(cls, api_type: str, api_version: str):
-        typed_api_type = ApiType.from_str(api_type) if api_type else ApiType.from_str(openai.api_type)
+        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

@@ -24,15 +24,17 @@ def create(
             api_version=api_version,
             organization=organization,
         )
-        typed_api_type, api_version = cls._get_api_type_and_version(api_type, api_version)
+        typed_api_type, api_version = cls._get_api_type_and_version(
+            api_type, api_version)
 
-        if typed_api_type == ApiType.AZURE:
+        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

@@ -4,21 +4,25 @@
 from openai.api_resources.abstract.api_resource import APIResource
 from openai.util import ApiType
 
+
 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)
-        if typed_api_type == ApiType.AZURE:
-            url = "/%s%s/%s?api-version=%s" % (cls.azure_api_prefix, base, extn, api_version)
+        typed_api_type, api_version = cls._get_api_type_and_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)
         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)

openai/api_resources/abstract/engine_api_resource.py

@@ -29,9 +29,10 @@ def class_url(
         # Namespaces are separated in object names with periods (.) and in URLs
         # 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)
+        typed_api_type, api_version = cls._get_api_type_and_version(
+            api_type, api_version)
 
-        if typed_api_type == ApiType.AZURE:
+        if typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD):
             if not api_version:
                 raise error.InvalidRequestError(
                     "An API version is required for the Azure API type."
@@ -107,7 +108,8 @@ def create(
         )
 
         if stream:
-            assert not isinstance(response, OpenAIResponse)  # must be an iterator
+            # must be an iterator
+            assert not isinstance(response, OpenAIResponse)
             return (
                 util.convert_to_openai_object(
                     line,
@@ -146,7 +148,7 @@ def instance_url(self):
         extn = quote_plus(id)
         params_connector = '?'
 
-        if self.typed_api_type == ApiType.AZURE:
+        if self.typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD):
             api_version = self.api_version or openai.api_version
             if not api_version:
                 raise error.InvalidRequestError(
@@ -163,13 +165,13 @@ def instance_url(self):
             )
             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

@@ -27,15 +27,17 @@ def list(
             organization=organization,
         )
 
-        typed_api_type, api_version = cls._get_api_type_and_version(api_type, api_version)
+        typed_api_type, api_version = cls._get_api_type_and_version(
+            api_type, api_version)
 
-        if typed_api_type == ApiType.AZURE:
+        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

@@ -12,9 +12,11 @@ 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)
-        if typed_api_type != util.ApiType.AZURE:
-            raise APIError("Deployment operations are only available for the Azure API type.")  
+        typed_api_type, _ = cls._get_api_type_and_version(
+            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.")
 
         if kwargs.get("model", None) is None:
             raise InvalidRequestError(
@@ -28,9 +30,9 @@ def create(cls, *args, **kwargs):
                 "Must provide a 'scale_settings' parameter to create a Deployment.",
                 param="scale_settings",
             )
-        
+
         if "scale_type" not in scale_settings or \
-            (scale_settings["scale_type"].lower() == 'manual' and "capacity" not in scale_settings):
+                (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",
@@ -40,24 +42,30 @@ 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)
-        if typed_api_type != util.ApiType.AZURE:
-            raise APIError("Deployment operations are only available for the Azure API type.")  
+        typed_api_type, _ = cls._get_api_type_and_version(
+            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.")
 
         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)
-        if typed_api_type != util.ApiType.AZURE:
-            raise APIError("Deployment operations are only available for the Azure API type.")  
+        typed_api_type, _ = cls._get_api_type_and_version(
+            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.")
 
         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)
-        if typed_api_type != util.ApiType.AZURE:
-            raise APIError("Deployment operations are only available for the Azure API type.")  
+        typed_api_type, _ = cls._get_api_type_and_version(
+            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.")
 
         return super().retrieve(*args, **kwargs)

openai/api_resources/engine.py

@@ -28,7 +28,7 @@ def generate(self, timeout=None, **params):
                 util.log_info("Waiting for model to warm up", error=e)
 
     def search(self, **params):
-        if self.typed_api_type == ApiType.AZURE:
+        if self.typed_api_type in (ApiType.AZURE, ApiType.AZURE_AD):
             return self.request("post", self.instance_url("search"), params)
         elif self.typed_api_type == ApiType.OPEN_AI:
             return self.request("post", self.instance_url() + "/search", params)