Upload 77 files

openai/__init__.py

@@ -0,0 +1,73 @@
+# OpenAI Python bindings.
+#
+# Originally forked from the MIT-licensed Stripe Python bindings.
+
+import os
+from typing import Optional
+
+from openai.api_resources import (
+    Answer,
+    Classification,
+    Completion,
+    Customer,
+    Edit,
+    Deployment,
+    Embedding,
+    Engine,
+    ErrorObject,
+    File,
+    FineTune,
+    Model,
+    Search,
+)
+from openai.error import APIError, InvalidRequestError, OpenAIError
+
+api_key = os.environ.get("OPENAI_API_KEY")
+# Path of a file with an API key, whose contents can change. Supercedes
+# `api_key` if set.  The main use case is volume-mounted Kubernetes secrets,
+# which are updated automatically.
+api_key_path: Optional[str] = os.environ.get("OPENAI_API_KEY_PATH")
+
+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 = "2021-11-01-preview" if api_type == "azure" else None
+verify_ssl_certs = True  # No effect. Certificates are always verified.
+proxy = None
+app_info = None
+enable_telemetry = False  # Ignored; the telemetry feature was removed.
+ca_bundle_path = None  # No longer used, feature was removed
+debug = False
+log = None  # Set to either 'debug' or 'info', controls console logging
+
+__all__ = [
+    "APIError",
+    "Answer",
+    "Classification",
+    "Completion",
+    "Customer",
+    "Edit",
+    "Deployment",
+    "Embedding",
+    "Engine",
+    "ErrorObject",
+    "File",
+    "FineTune",
+    "InvalidRequestError",
+    "Model",
+    "OpenAIError",
+    "Search",
+    "api_base",
+    "api_key",
+    "api_type",
+    "api_key_path",
+    "api_version",
+    "app_info",
+    "ca_bundle_path",
+    "debug",
+    "enable_elemetry",
+    "log",
+    "organization",
+    "proxy",
+    "verify_ssl_certs",
+]

openai/_openai_scripts.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+import argparse
+import logging
+import sys
+
+import openai
+from openai.cli import api_register, display_error, tools_register, wandb_register
+
+logger = logging.getLogger()
+formatter = logging.Formatter("[%(asctime)s] %(message)s")
+handler = logging.StreamHandler(sys.stderr)
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=None)
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="count",
+        dest="verbosity",
+        default=0,
+        help="Set verbosity.",
+    )
+    parser.add_argument("-b", "--api-base", help="What API base url to use.")
+    parser.add_argument("-k", "--api-key", help="What API key to use.")
+    parser.add_argument(
+        "-o",
+        "--organization",
+        help="Which organization to run as (will use your default organization if not specified)",
+    )
+
+    def help(args):
+        parser.print_help()
+
+    parser.set_defaults(func=help)
+
+    subparsers = parser.add_subparsers()
+    sub_api = subparsers.add_parser("api", help="Direct API calls")
+    sub_tools = subparsers.add_parser("tools", help="Client side tools for convenience")
+    sub_wandb = subparsers.add_parser("wandb", help="Logging with Weights & Biases")
+
+    api_register(sub_api)
+    tools_register(sub_tools)
+    wandb_register(sub_wandb)
+
+    args = parser.parse_args()
+    if args.verbosity == 1:
+        logger.setLevel(logging.INFO)
+    elif args.verbosity >= 2:
+        logger.setLevel(logging.DEBUG)
+
+    openai.debug = True
+    if args.api_key is not None:
+        openai.api_key = args.api_key
+    if args.api_base is not None:
+        openai.api_base = args.api_base
+    if args.organization is not None:
+        openai.organization = args.organization
+
+    try:
+        args.func(args)
+    except openai.error.OpenAIError as e:
+        display_error(e)
+        return 1
+    except KeyboardInterrupt:
+        sys.stderr.write("\n")
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

openai/api_requestor.py

@@ -0,0 +1,365 @@
+import json
+import platform
+import threading
+import warnings
+from email import header
+from json import JSONDecodeError
+from typing import Dict, Iterator, Optional, Tuple, Union
+from urllib.parse import urlencode, urlsplit, urlunsplit
+
+import requests
+
+import openai
+from openai import error, util, version
+from openai.openai_response import OpenAIResponse
+from openai.util import ApiType
+
+TIMEOUT_SECS = 600
+MAX_CONNECTION_RETRIES = 2
+
+# Has one attribute per thread, 'session'.
+_thread_context = threading.local()
+
+
+def _build_api_url(url, query):
+    scheme, netloc, path, base_query, fragment = urlsplit(url)
+
+    if base_query:
+        query = "%s&%s" % (base_query, query)
+
+    return urlunsplit((scheme, netloc, path, query, fragment))
+
+
+def _requests_proxies_arg(proxy) -> Optional[Dict[str, str]]:
+    """Returns a value suitable for the 'proxies' argument to 'requests.request."""
+    if proxy is None:
+        return None
+    elif isinstance(proxy, str):
+        return {"http": proxy, "https": proxy}
+    elif isinstance(proxy, dict):
+        return proxy.copy()
+    else:
+        raise ValueError(
+            "'openai.proxy' must be specified as either a string URL or a dict with string URL under the https and/or http keys."
+        )
+
+
+def _make_session() -> requests.Session:
+    if not openai.verify_ssl_certs:
+        warnings.warn("verify_ssl_certs is ignored; openai always verifies.")
+    s = requests.Session()
+    proxies = _requests_proxies_arg(openai.proxy)
+    if proxies:
+        s.proxies = proxies
+    s.mount(
+        "https://",
+        requests.adapters.HTTPAdapter(max_retries=MAX_CONNECTION_RETRIES),
+    )
+    return s
+
+
+def parse_stream(rbody):
+    for line in rbody:
+        if line:
+            if line == b"data: [DONE]":
+                # return here will cause GeneratorExit exception in urllib3
+                # and it will close http connection with TCP Reset
+                continue
+            if hasattr(line, "decode"):
+                line = line.decode("utf-8")
+            if line.startswith("data: "):
+                line = line[len("data: ") :]
+            yield line
+
+
+class APIRequestor:
+    def __init__(
+        self,
+        key=None,
+        api_base=None,
+        api_type=None,
+        api_version=None,
+        organization=None,
+    ):
+        self.api_base = api_base or openai.api_base
+        self.api_key = key or util.default_api_key()
+        self.api_type = (
+            ApiType.from_str(api_type)
+            if api_type
+            else ApiType.from_str(openai.api_type)
+        )
+        self.api_version = api_version or openai.api_version
+        self.organization = organization or openai.organization
+
+    @classmethod
+    def format_app_info(cls, info):
+        str = info["name"]
+        if info["version"]:
+            str += "/%s" % (info["version"],)
+        if info["url"]:
+            str += " (%s)" % (info["url"],)
+        return str
+
+    def request(
+        self,
+        method,
+        url,
+        params=None,
+        headers=None,
+        files=None,
+        stream=False,
+        request_id: Optional[str] = None,
+    ) -> Tuple[Union[OpenAIResponse, Iterator[OpenAIResponse]], bool, str]:
+        result = self.request_raw(
+            method.lower(),
+            url,
+            params=params,
+            supplied_headers=headers,
+            files=files,
+            stream=stream,
+            request_id=request_id,
+        )
+        resp, got_stream = self._interpret_response(result, stream)
+        return resp, got_stream, self.api_key
+
+    def handle_error_response(self, rbody, rcode, resp, rheaders, stream_error=False):
+        try:
+            error_data = resp["error"]
+        except (KeyError, TypeError):
+            raise error.APIError(
+                "Invalid response object from API: %r (HTTP response code "
+                "was %d)" % (rbody, rcode),
+                rbody,
+                rcode,
+                resp,
+            )
+
+        if "internal_message" in error_data:
+            error_data["message"] += "\n\n" + error_data["internal_message"]
+
+        util.log_info(
+            "OpenAI API error received",
+            error_code=error_data.get("code"),
+            error_type=error_data.get("type"),
+            error_message=error_data.get("message"),
+            error_param=error_data.get("param"),
+            stream_error=stream_error,
+        )
+
+        # Rate limits were previously coded as 400's with code 'rate_limit'
+        if rcode == 429:
+            return error.RateLimitError(
+                error_data.get("message"), rbody, rcode, resp, rheaders
+            )
+        elif rcode in [400, 404, 415]:
+            return error.InvalidRequestError(
+                error_data.get("message"),
+                error_data.get("param"),
+                error_data.get("code"),
+                rbody,
+                rcode,
+                resp,
+                rheaders,
+            )
+        elif rcode == 401:
+            return error.AuthenticationError(
+                error_data.get("message"), rbody, rcode, resp, rheaders
+            )
+        elif rcode == 403:
+            return error.PermissionError(
+                error_data.get("message"), rbody, rcode, resp, rheaders
+            )
+        elif rcode == 409:
+            return error.TryAgain(
+                error_data.get("message"), rbody, rcode, resp, rheaders
+            )
+        elif stream_error:
+            # TODO: we will soon attach status codes to stream errors
+            parts = [error_data.get("message"), "(Error occurred while streaming.)"]
+            message = " ".join([p for p in parts if p is not None])
+            return error.APIError(message, rbody, rcode, resp, rheaders)
+        else:
+            return error.APIError(
+                error_data.get("message"), rbody, rcode, resp, rheaders
+            )
+
+    def request_headers(
+        self, method: str, extra, request_id: Optional[str]
+    ) -> Dict[str, str]:
+        user_agent = "OpenAI/v1 PythonBindings/%s" % (version.VERSION,)
+        if openai.app_info:
+            user_agent += " " + self.format_app_info(openai.app_info)
+
+        uname_without_node = " ".join(
+            v for k, v in platform.uname()._asdict().items() if k != "node"
+        )
+        ua = {
+            "bindings_version": version.VERSION,
+            "httplib": "requests",
+            "lang": "python",
+            "lang_version": platform.python_version(),
+            "platform": platform.platform(),
+            "publisher": "openai",
+            "uname": uname_without_node,
+        }
+        if openai.app_info:
+            ua["application"] = openai.app_info
+
+        headers = {
+            "X-OpenAI-Client-User-Agent": json.dumps(ua),
+            "User-Agent": user_agent,
+        }
+
+        headers.update(util.api_key_to_header(self.api_type, self.api_key))
+
+        if self.organization:
+            headers["OpenAI-Organization"] = self.organization
+
+        if self.api_version is not None and self.api_type == ApiType.OPEN_AI:
+            headers["OpenAI-Version"] = self.api_version
+        if request_id is not None:
+            headers["X-Request-Id"] = request_id
+        if openai.debug:
+            headers["OpenAI-Debug"] = "true"
+        headers.update(extra)
+
+        return headers
+
+    def _validate_headers(
+        self, supplied_headers: Optional[Dict[str, str]]
+    ) -> Dict[str, str]:
+        headers: Dict[str, str] = {}
+        if supplied_headers is None:
+            return headers
+
+        if not isinstance(supplied_headers, dict):
+            raise TypeError("Headers must be a dictionary")
+
+        for k, v in supplied_headers.items():
+            if not isinstance(k, str):
+                raise TypeError("Header keys must be strings")
+            if not isinstance(v, str):
+                raise TypeError("Header values must be strings")
+            headers[k] = v
+
+        # NOTE: It is possible to do more validation of the headers, but a request could always
+        # be made to the API manually with invalid headers, so we need to handle them server side.
+
+        return headers
+
+    def request_raw(
+        self,
+        method,
+        url,
+        *,
+        params=None,
+        supplied_headers: Dict[str, str] = None,
+        files=None,
+        stream: bool = False,
+        request_id: Optional[str] = None,
+    ) -> requests.Response:
+        abs_url = "%s%s" % (self.api_base, url)
+        headers = self._validate_headers(supplied_headers)
+
+        data = None
+        if method == "get" or method == "delete":
+            if params:
+                encoded_params = urlencode(
+                    [(k, v) for k, v in params.items() if v is not None]
+                )
+                abs_url = _build_api_url(abs_url, encoded_params)
+        elif method in {"post", "put"}:
+            if params and files:
+                raise ValueError("At most one of params and files may be specified.")
+            if params:
+                data = json.dumps(params).encode()
+                headers["Content-Type"] = "application/json"
+        else:
+            raise error.APIConnectionError(
+                "Unrecognized HTTP method %r. This may indicate a bug in the "
+                "OpenAI bindings. Please contact support@openai.com for "
+                "assistance." % (method,)
+            )
+
+        headers = self.request_headers(method, headers, request_id)
+
+        util.log_info("Request to OpenAI API", method=method, path=abs_url)
+        util.log_debug("Post details", data=data, api_version=self.api_version)
+
+        if not hasattr(_thread_context, "session"):
+            _thread_context.session = _make_session()
+        try:
+            result = _thread_context.session.request(
+                method,
+                abs_url,
+                headers=headers,
+                data=data,
+                files=files,
+                stream=stream,
+                timeout=TIMEOUT_SECS,
+            )
+        except requests.exceptions.RequestException as e:
+            raise error.APIConnectionError("Error communicating with OpenAI") from e
+        util.log_info(
+            "OpenAI API response",
+            path=abs_url,
+            response_code=result.status_code,
+            processing_ms=result.headers.get("OpenAI-Processing-Ms"),
+        )
+        # Don't read the whole stream for debug logging unless necessary.
+        if openai.log == "debug":
+            util.log_debug(
+                "API response body", body=result.content, headers=result.headers
+            )
+        return result
+
+    def _interpret_response(
+        self, result: requests.Response, stream: bool
+    ) -> Tuple[Union[OpenAIResponse, Iterator[OpenAIResponse]], bool]:
+        """Returns the response(s) and a bool indicating whether it is a stream."""
+        if stream and "text/event-stream" in result.headers.get("Content-Type", ""):
+            return (
+                self._interpret_response_line(
+                    line, result.status_code, result.headers, stream=True
+                )
+                for line in parse_stream(result.iter_lines())
+            ), True
+        else:
+            return (
+                self._interpret_response_line(
+                    result.content, result.status_code, result.headers, stream=False
+                ),
+                False,
+            )
+
+    def _interpret_response_line(
+        self, rbody, rcode, rheaders, stream: bool
+    ) -> OpenAIResponse:
+        # HTTP 204 response code does not have any content in the body.
+        if rcode == 204:
+            return OpenAIResponse(None, rheaders)
+
+        if rcode == 503:
+            raise error.ServiceUnavailableError(
+                "The server is overloaded or not ready yet.",
+                rbody,
+                rcode,
+                headers=rheaders,
+            )
+        try:
+            if hasattr(rbody, "decode"):
+                rbody = rbody.decode("utf-8")
+            data = json.loads(rbody)
+        except (JSONDecodeError, UnicodeDecodeError):
+            raise error.APIError(
+                f"HTTP code {rcode} from API ({rbody})", rbody, rcode, headers=rheaders
+            )
+        resp = OpenAIResponse(data, rheaders)
+        # In the future, we might add a "status" parameter to errors
+        # to better handle the "error while streaming" case.
+        stream_error = stream and "error" in resp.data
+        if stream_error or not 200 <= rcode < 300:
+            raise self.handle_error_response(
+                rbody, rcode, resp.data, rheaders, stream_error=stream_error
+            )
+        return resp

openai/api_resources/__init__.py

@@ -0,0 +1,13 @@
+from openai.api_resources.answer import Answer  # noqa: F401
+from openai.api_resources.classification import Classification  # noqa: F401
+from openai.api_resources.completion import Completion  # noqa: F401
+from openai.api_resources.customer import Customer  # noqa: F401
+from openai.api_resources.edit import Edit  # noqa: F401
+from openai.api_resources.deployment import Deployment  # noqa: F401
+from openai.api_resources.embedding import Embedding  # noqa: F401
+from openai.api_resources.engine import Engine  # noqa: F401
+from openai.api_resources.error_object import ErrorObject  # noqa: F401
+from openai.api_resources.file import File  # noqa: F401
+from openai.api_resources.fine_tune import FineTune  # noqa: F401
+from openai.api_resources.model import Model  # noqa: F401
+from openai.api_resources.search import Search  # noqa: F401

openai/api_resources/abstract/__init__.py

@@ -0,0 +1,10 @@
+# flake8: noqa
+
+from openai.api_resources.abstract.api_resource import APIResource
+from openai.api_resources.abstract.createable_api_resource import CreateableAPIResource
+from openai.api_resources.abstract.deletable_api_resource import DeletableAPIResource
+from openai.api_resources.abstract.listable_api_resource import ListableAPIResource
+from openai.api_resources.abstract.nested_resource_class_methods import (
+    nested_resource_class_methods,
+)
+from openai.api_resources.abstract.updateable_api_resource import UpdateableAPIResource

openai/api_resources/abstract/api_resource.py

@@ -0,0 +1,117 @@
+from urllib.parse import quote_plus
+
+import openai
+from openai import api_requestor, error, util
+from openai.openai_object import OpenAIObject
+from openai.util import ApiType
+
+
+class APIResource(OpenAIObject):
+    api_prefix = ""
+    azure_api_prefix = "openai"
+    azure_deployments_prefix = "deployments"
+
+    @classmethod
+    def retrieve(cls, id, api_key=None, request_id=None, **params):
+        instance = cls(id, api_key, **params)
+        instance.refresh(request_id=request_id)
+        return instance
+
+    def refresh(self, request_id=None):
+        self.refresh_from(
+            self.request("get", self.instance_url(), request_id=request_id)
+        )
+        return self
+
+    @classmethod
+    def class_url(cls):
+        if cls == APIResource:
+            raise NotImplementedError(
+                "APIResource is an abstract class. You should perform actions on its subclasses."
+            )
+        # 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
+        if cls.api_prefix:
+            return "/%s/%s" % (cls.api_prefix, base)
+        return "/%s" % (base)
+
+    def instance_url(self, operation=None):
+        id = self.get("id")
+
+        if not isinstance(id, str):
+            raise error.InvalidRequestError(
+                "Could not determine which URL to request: %s instance "
+                "has invalid ID: %r, %s. ID should be of type `str` (or"
+                " `unicode`)" % (type(self).__name__, id, type(id)),
+                "id",
+            )
+        api_version = self.api_version or openai.api_version
+        extn = quote_plus(id)
+
+        if self.typed_api_type == ApiType.AZURE:
+            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" % (
+                    self.azure_api_prefix,
+                    base,
+                    extn,
+                    api_version
+                )
+
+            return "/%s/%s/%s/%s?api-version=%s" % (
+                self.azure_api_prefix,
+                self.azure_deployments_prefix,
+                extn,
+                operation,
+                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)
+
+    # The `method_` and `url_` arguments are suffixed with an underscore to
+    # avoid conflicting with actual request parameters in `params`.
+    @classmethod
+    def _static_request(
+        cls,
+        method_,
+        url_,
+        api_key=None,
+        api_base=None,
+        api_type=None,
+        request_id=None,
+        api_version=None,
+        organization=None,
+        **params,
+    ):
+        requestor = api_requestor.APIRequestor(
+            api_key,
+            api_version=api_version,
+            organization=organization,
+            api_base=api_base,
+            api_type=api_type
+        )
+        response, _, api_key = requestor.request(
+            method_, url_, params, request_id=request_id
+        )
+        return util.convert_to_openai_object(
+            response, api_key, api_version, organization
+        )
+
+    @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_version = api_version or openai.api_version
+        return (typed_api_type, typed_api_version)
+

openai/api_resources/abstract/createable_api_resource.py

@@ -0,0 +1,47 @@
+from openai import api_requestor, util, error
+from openai.api_resources.abstract.api_resource import APIResource
+from openai.util import ApiType
+
+
+class CreateableAPIResource(APIResource):
+    plain_old_data = False
+
+    @classmethod
+    def create(
+        cls,
+        api_key=None,
+        api_base=None,
+        api_type=None,
+        request_id=None,
+        api_version=None,
+        organization=None,
+        **params,
+    ):
+        requestor = api_requestor.APIRequestor(
+            api_key,
+            api_base=api_base,
+            api_type=api_type,
+            api_version=api_version,
+            organization=organization,
+        )
+        typed_api_type, api_version = cls._get_api_type_and_version(api_type, api_version)
+
+        if typed_api_type == ApiType.AZURE:
+            base = cls.class_url()
+            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)            
+
+        response, _, api_key = requestor.request(
+            "post", url, params, request_id=request_id
+        )
+
+        return util.convert_to_openai_object(
+            response,
+            api_key,
+            api_version,
+            organization,
+            plain_old_data=cls.plain_old_data,
+        )

openai/api_resources/abstract/deletable_api_resource.py

@@ -0,0 +1,24 @@
+from urllib.parse import quote_plus
+
+from openai import error
+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.")
+
+        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)
+        elif typed_api_type == ApiType.OPEN_AI:
+            url = "%s/%s" % (base, extn)
+        else:
+            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

@@ -0,0 +1,192 @@
+import time
+from pydoc import apropos
+from typing import Optional
+from urllib.parse import quote_plus
+
+import openai
+from openai import api_requestor, error, util
+from openai.api_resources.abstract.api_resource import APIResource
+from openai.openai_response import OpenAIResponse
+from openai.util import ApiType
+
+MAX_TIMEOUT = 20
+
+
+class EngineAPIResource(APIResource):
+    engine_required = True
+    plain_old_data = False
+
+    def __init__(self, engine: Optional[str] = None, **kwargs):
+        super().__init__(engine=engine, **kwargs)
+
+    @classmethod
+    def class_url(
+        cls,
+        engine: Optional[str] = None,
+        api_type: Optional[str] = None,
+        api_version: Optional[str] = None,
+    ):
+        # 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)
+
+        if typed_api_type == ApiType.AZURE:
+            if not api_version:
+                raise error.InvalidRequestError(
+                    "An API version is required for the Azure API type."
+                )
+            if engine is None:
+                raise error.InvalidRequestError(
+                    "You must provide the deployment name in the 'engine' parameter to access the Azure OpenAI service"
+                )
+            extn = quote_plus(engine)
+            return "/%s/%s/%s/%s?api-version=%s" % (
+                cls.azure_api_prefix,
+                cls.azure_deployments_prefix,
+                extn,
+                base,
+                api_version
+            )
+
+        elif typed_api_type == ApiType.OPEN_AI:
+            if engine is None:
+                return "/%s" % (base)
+
+            extn = quote_plus(engine)
+            return "/engines/%s/%s" % (extn, base)
+
+        else:
+            raise error.InvalidAPIType("Unsupported API type %s" % api_type)
+
+    @classmethod
+    def create(
+        cls,
+        api_key=None,
+        api_base=None,
+        api_type=None,
+        request_id=None,
+        api_version=None,
+        organization=None,
+        **params,
+    ):
+        engine = params.pop("engine", None)
+        timeout = params.pop("timeout", None)
+        stream = params.get("stream", False)
+        headers = params.pop("headers", None)
+        if engine is None and cls.engine_required:
+            raise error.InvalidRequestError(
+                "Must provide an 'engine' parameter to create a %s" % cls, "engine"
+            )
+
+        if timeout is None:
+            # No special timeout handling
+            pass
+        elif timeout > 0:
+            # API only supports timeouts up to MAX_TIMEOUT
+            params["timeout"] = min(timeout, MAX_TIMEOUT)
+            timeout = (timeout - params["timeout"]) or None
+        elif timeout == 0:
+            params["timeout"] = MAX_TIMEOUT
+
+        requestor = api_requestor.APIRequestor(
+            api_key,
+            api_base=api_base,
+            api_type=api_type,
+            api_version=api_version,
+            organization=organization,
+        )
+        url = cls.class_url(engine, api_type, api_version)
+        response, _, api_key = requestor.request(
+            "post",
+            url,
+            params=params,
+            headers=headers,
+            stream=stream,
+            request_id=request_id,
+        )
+
+        if stream:
+            assert not isinstance(response, OpenAIResponse)  # must be an iterator
+            return (
+                util.convert_to_openai_object(
+                    line,
+                    api_key,
+                    api_version,
+                    organization,
+                    engine=engine,
+                    plain_old_data=cls.plain_old_data,
+                )
+                for line in response
+            )
+        else:
+            obj = util.convert_to_openai_object(
+                response,
+                api_key,
+                api_version,
+                organization,
+                engine=engine,
+                plain_old_data=cls.plain_old_data,
+            )
+
+            if timeout is not None:
+                obj.wait(timeout=timeout or None)
+
+        return obj
+
+    def instance_url(self):
+        id = self.get("id")
+
+        if not isinstance(id, str):
+            raise error.InvalidRequestError(
+                f"Could not determine which URL to request: {type(self).__name__} instance has invalid ID: {id}, {type(id)}. ID should be of type str.",
+                "id",
+            )
+
+        extn = quote_plus(id)
+        params_connector = '?'
+
+        if self.typed_api_type == ApiType.AZURE:
+            api_version = self.api_version or openai.api_version
+            if not api_version:
+                raise error.InvalidRequestError(
+                    "An API version is required for the Azure API type."
+                )
+            base = self.OBJECT_NAME.replace(".", "/")
+            url = "/%s/%s/%s/%s/%s?api-version=%s" % (
+                self.azure_api_prefix,
+                self.azure_deployments_prefix,
+                self.engine,
+                base,
+                extn,
+                api_version
+            )
+            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)
+
+        timeout = self.get("timeout")
+        if timeout is not None:
+            timeout = quote_plus(str(timeout))
+            url += params_connector + "timeout={}".format(timeout)
+        return url
+
+    def wait(self, timeout=None):
+        start = time.time()
+        while self.status != "complete":
+            self.timeout = (
+                min(timeout + start - time.time(), MAX_TIMEOUT)
+                if timeout is not None
+                else MAX_TIMEOUT
+            )
+            if self.timeout < 0:
+                del self.timeout
+                break
+            self.refresh()
+        return self

openai/api_resources/abstract/listable_api_resource.py

@@ -0,0 +1,47 @@
+from openai import api_requestor, util, error
+from openai.api_resources.abstract.api_resource import APIResource
+from openai.util import ApiType
+
+
+class ListableAPIResource(APIResource):
+    @classmethod
+    def auto_paging_iter(cls, *args, **params):
+        return cls.list(*args, **params).auto_paging_iter()
+
+    @classmethod
+    def list(
+        cls,
+        api_key=None,
+        request_id=None,
+        api_version=None,
+        organization=None,
+        api_base=None,
+        api_type=None,
+        **params,
+    ):
+        requestor = api_requestor.APIRequestor(
+            api_key,
+            api_base=api_base or cls.api_base(),
+            api_version=api_version,
+            api_type=api_type,
+            organization=organization,
+        )
+
+        typed_api_type, api_version = cls._get_api_type_and_version(api_type, api_version)
+
+        if typed_api_type == ApiType.AZURE:
+            base = cls.class_url()
+            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)            
+
+        response, _, api_key = requestor.request(
+            "get", url, params, request_id=request_id
+        )
+        openai_object = util.convert_to_openai_object(
+            response, api_key, api_version, organization
+        )
+        openai_object._retrieve_params = params
+        return openai_object

openai/api_resources/abstract/nested_resource_class_methods.py

@@ -0,0 +1,102 @@
+from urllib.parse import quote_plus
+
+from openai import api_requestor, util
+
+
+def nested_resource_class_methods(
+    resource, path=None, operations=None, resource_plural=None
+):
+    if resource_plural is None:
+        resource_plural = "%ss" % resource
+    if path is None:
+        path = resource_plural
+    if operations is None:
+        raise ValueError("operations list required")
+
+    def wrapper(cls):
+        def nested_resource_url(cls, id, nested_id=None):
+            url = "%s/%s/%s" % (cls.class_url(), quote_plus(id), quote_plus(path))
+            if nested_id is not None:
+                url += "/%s" % quote_plus(nested_id)
+            return url
+
+        resource_url_method = "%ss_url" % resource
+        setattr(cls, resource_url_method, classmethod(nested_resource_url))
+
+        def nested_resource_request(
+            cls,
+            method,
+            url,
+            api_key=None,
+            request_id=None,
+            api_version=None,
+            organization=None,
+            **params,
+        ):
+            requestor = api_requestor.APIRequestor(
+                api_key, api_version=api_version, organization=organization
+            )
+            response, _, api_key = requestor.request(
+                method, url, params, request_id=request_id
+            )
+            return util.convert_to_openai_object(
+                response, api_key, api_version, organization
+            )
+
+        resource_request_method = "%ss_request" % resource
+        setattr(cls, resource_request_method, classmethod(nested_resource_request))
+
+        for operation in operations:
+            if operation == "create":
+
+                def create_nested_resource(cls, id, **params):
+                    url = getattr(cls, resource_url_method)(id)
+                    return getattr(cls, resource_request_method)("post", url, **params)
+
+                create_method = "create_%s" % resource
+                setattr(cls, create_method, classmethod(create_nested_resource))
+
+            elif operation == "retrieve":
+
+                def retrieve_nested_resource(cls, id, nested_id, **params):
+                    url = getattr(cls, resource_url_method)(id, nested_id)
+                    return getattr(cls, resource_request_method)("get", url, **params)
+
+                retrieve_method = "retrieve_%s" % resource
+                setattr(cls, retrieve_method, classmethod(retrieve_nested_resource))
+
+            elif operation == "update":
+
+                def modify_nested_resource(cls, id, nested_id, **params):
+                    url = getattr(cls, resource_url_method)(id, nested_id)
+                    return getattr(cls, resource_request_method)("post", url, **params)
+
+                modify_method = "modify_%s" % resource
+                setattr(cls, modify_method, classmethod(modify_nested_resource))
+
+            elif operation == "delete":
+
+                def delete_nested_resource(cls, id, nested_id, **params):
+                    url = getattr(cls, resource_url_method)(id, nested_id)
+                    return getattr(cls, resource_request_method)(
+                        "delete", url, **params
+                    )
+
+                delete_method = "delete_%s" % resource
+                setattr(cls, delete_method, classmethod(delete_nested_resource))
+
+            elif operation == "list":
+
+                def list_nested_resources(cls, id, **params):
+                    url = getattr(cls, resource_url_method)(id)
+                    return getattr(cls, resource_request_method)("get", url, **params)
+
+                list_method = "list_%s" % resource_plural
+                setattr(cls, list_method, classmethod(list_nested_resources))
+
+            else:
+                raise ValueError("Unknown operation: %s" % operation)
+
+        return cls
+
+    return wrapper

openai/api_resources/abstract/updateable_api_resource.py

@@ -0,0 +1,10 @@
+from urllib.parse import quote_plus
+
+from openai.api_resources.abstract.api_resource import APIResource
+
+
+class UpdateableAPIResource(APIResource):
+    @classmethod
+    def modify(cls, sid, **params):
+        url = "%s/%s" % (cls.class_url(), quote_plus(sid))
+        return cls._static_request("post", url, **params)

openai/api_resources/answer.py

@@ -0,0 +1,12 @@
+from openai.openai_object import OpenAIObject
+
+
+class Answer(OpenAIObject):
+    @classmethod
+    def get_url(self):
+        return "/answers"
+
+    @classmethod
+    def create(cls, **params):
+        instance = cls()
+        return instance.request("post", cls.get_url(), params)

openai/api_resources/classification.py

@@ -0,0 +1,12 @@
+from openai.openai_object import OpenAIObject
+
+
+class Classification(OpenAIObject):
+    @classmethod
+    def get_url(self):
+        return "/classifications"
+
+    @classmethod
+    def create(cls, **params):
+        instance = cls()
+        return instance.request("post", cls.get_url(), params)