aibuildai 0.0.1__py3-none-any.whl

aibuildai-0.0.1.dist-info/METADATA

@@ -0,0 +1,356 @@
+Metadata-Version: 2.4
+Name: aibuildai
+Version: 0.0.1
+Summary: Python client library for the aibuildai API
+Home-page: https://github.com/open-lm/openai-python
+Author: aibuildai
+Author-email: support@gensei.ai
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7.1
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.20
+Requires-Dist: tqdm
+Requires-Dist: typing_extensions; python_version < "3.8"
+Requires-Dist: aiohttp
+Provides-Extra: dev
+Requires-Dist: black~=21.6b0; extra == "dev"
+Requires-Dist: pytest==6.*; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Provides-Extra: datalib
+Requires-Dist: numpy; extra == "datalib"
+Requires-Dist: pandas>=1.2.3; extra == "datalib"
+Requires-Dist: pandas-stubs>=1.1.0.11; extra == "datalib"
+Requires-Dist: openpyxl>=3.0.7; extra == "datalib"
+Provides-Extra: wandb
+Requires-Dist: wandb; extra == "wandb"
+Requires-Dist: numpy; extra == "wandb"
+Requires-Dist: pandas>=1.2.3; extra == "wandb"
+Requires-Dist: pandas-stubs>=1.1.0.11; extra == "wandb"
+Requires-Dist: openpyxl>=3.0.7; extra == "wandb"
+Provides-Extra: embeddings
+Requires-Dist: scikit-learn>=1.0.2; extra == "embeddings"
+Requires-Dist: tenacity>=8.0.1; extra == "embeddings"
+Requires-Dist: matplotlib; extra == "embeddings"
+Requires-Dist: plotly; extra == "embeddings"
+Requires-Dist: numpy; extra == "embeddings"
+Requires-Dist: scipy; extra == "embeddings"
+Requires-Dist: pandas>=1.2.3; extra == "embeddings"
+Requires-Dist: pandas-stubs>=1.1.0.11; extra == "embeddings"
+Requires-Dist: openpyxl>=3.0.7; extra == "embeddings"
+Dynamic: license-file
+
+# OpenAI Python Library
+
+The OpenAI Python library provides convenient access to the OpenAI API
+from applications written in the Python language. It includes a
+pre-defined set of classes for API resources that initialize
+themselves dynamically from API responses which makes it compatible
+with a wide range of versions of the OpenAI API.
+
+You can find usage examples for the OpenAI Python library in our [API reference](https://beta.openai.com/docs/api-reference?lang=python) and the [OpenAI Cookbook](https://github.com/openai/openai-cookbook/).
+
+## Installation
+
+You don't need this source code unless you want to modify the package. If you just
+want to use the package, just run:
+
+```sh
+pip install --upgrade aibuildai
+```
+
+Install from source with:
+
+```sh
+python setup.py install
+```
+
+### Optional dependencies
+
+Install dependencies for [`openai.embeddings_utils`](openai/embeddings_utils.py):
+
+```sh
+pip install openai[embeddings]
+```
+
+Install support for [Weights & Biases](https://wandb.me/openai-docs):
+
+```
+pip install openai[wandb]
+```
+
+Data libraries like `numpy` and `pandas` are not installed by default due to their size. They’re needed for some functionality of this library, but generally not for talking to the API. If you encounter a `MissingDependencyError`, install them with:
+
+```sh
+pip install openai[datalib]
+```
+
+## Usage
+
+The library needs to be configured with your account's secret key which is available on the [website](https://platform.openai.com/account/api-keys). Either set it as the `OPENAI_API_KEY` environment variable before using the library:
+
+```bash
+export OPENAI_API_KEY='sk-...'
+```
+
+Or set `openai.api_key` to its value:
+
+```python
+import openai
+openai.api_key = "sk-..."
+
+# list models
+models = openai.Model.list()
+
+# print the first model's id
+print(models.data[0].id)
+
+# create a chat completion
+chat_completion = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "Hello world"}])
+
+# print the chat completion
+print(chat_completion.choices[0].message.content)
+```
+
+### Params
+
+All endpoints have a `.create` method that supports a `request_timeout` param. This param takes a `Union[float, Tuple[float, float]]` and will raise an `openai.error.Timeout` error if the request exceeds that time in seconds (See: https://requests.readthedocs.io/en/latest/user/quickstart/#timeouts).
+
+### Microsoft Azure Endpoints
+
+In order to use the library with Microsoft Azure endpoints, you need to set the `api_type`, `api_base` and `api_version` in addition to the `api_key`. The `api_type` must be set to 'azure' and the others correspond to the properties of your endpoint.
+In addition, the deployment name must be passed as the engine parameter.
+
+```python
+import openai
+openai.api_type = "azure"
+openai.api_key = "..."
+openai.api_base = "https://example-endpoint.openai.azure.com"
+openai.api_version = "2023-05-15"
+
+# create a chat completion
+chat_completion = openai.ChatCompletion.create(deployment_id="deployment-name", model="gpt-3.5-turbo", messages=[{"role": "user", "content": "Hello world"}])
+
+# print the completion
+print(completion.choices[0].message.content)
+```
+
+Please note that for the moment, the Microsoft Azure endpoints can only be used for completion, embedding, and fine-tuning operations.
+For a detailed example of how to use fine-tuning and other operations using Azure endpoints, please check out the following Jupyter notebooks:
+
+- [Using Azure completions](https://github.com/openai/openai-cookbook/tree/main/examples/azure/completions.ipynb)
+- [Using Azure fine-tuning](https://github.com/openai/openai-cookbook/tree/main/examples/azure/finetuning.ipynb)
+- [Using Azure embeddings](https://github.com/openai/openai-cookbook/blob/main/examples/azure/embeddings.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/.default")
+
+# Setup parameters
+openai.api_type = "azure_ad"
+openai.api_key = token.token
+openai.api_base = "https://example-endpoint.openai.azure.com/"
+openai.api_version = "2023-05-15"
+
+# ...
+```
+
+### Command-line interface
+
+This library additionally provides an `openai` command-line utility
+which makes it easy to interact with the API from your terminal. Run
+`openai api -h` for usage.
+
+```sh
+# list models
+openai api models.list
+
+# create a chat completion (gpt-3.5-turbo, gpt-4, etc.)
+openai api chat_completions.create -m gpt-3.5-turbo -g user "Hello world"
+
+# create a completion (text-davinci-003, text-davinci-002, ada, babbage, curie, davinci, etc.)
+openai api completions.create -m ada -p "Hello world"
+
+# generate images via DALL·E API
+openai api image.create -p "two dogs playing chess, cartoon" -n 1
+
+# using openai through a proxy
+openai --proxy=http://proxy.com api models.list
+```
+
+## Example code
+
+Examples of how to use this Python library to accomplish various tasks can be found in the [OpenAI Cookbook](https://github.com/openai/openai-cookbook/). It contains code examples for:
+
+- Classification using fine-tuning
+- Clustering
+- Code search
+- Customizing embeddings
+- Question answering from a corpus of documents
+- Recommendations
+- Visualization of embeddings
+- And more
+
+Prior to July 2022, this OpenAI Python library hosted code examples in its examples folder, but since then all examples have been migrated to the [OpenAI Cookbook](https://github.com/openai/openai-cookbook/).
+
+### Chat Completions
+
+Conversational models such as `gpt-3.5-turbo` can be called using the chat completions endpoint.
+
+```python
+import openai
+openai.api_key = "sk-..."  # supply your API key however you choose
+
+completion = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "Hello world"}])
+print(completion.choices[0].message.content)
+```
+
+### Completions
+
+Text models such as `text-davinci-003`, `text-davinci-002` and earlier (`ada`, `babbage`, `curie`, `davinci`, etc.) can be called using the completions endpoint.
+
+```python
+import openai
+openai.api_key = "sk-..."  # supply your API key however you choose
+
+completion = openai.Completion.create(model="text-davinci-003", prompt="Hello world")
+print(completion.choices[0].text)
+```
+
+### Embeddings
+
+In the OpenAI Python library, an embedding represents a text string as a fixed-length vector of floating point numbers. Embeddings are designed to measure the similarity or relevance between text strings.
+
+To get an embedding for a text string, you can use the embeddings method as follows in Python:
+
+```python
+import openai
+openai.api_key = "sk-..."  # supply your API key however you choose
+
+# choose text to embed
+text_string = "sample text"
+
+# choose an embedding
+model_id = "text-similarity-davinci-001"
+
+# compute the embedding of the text
+embedding = openai.Embedding.create(input=text_string, model=model_id)['data'][0]['embedding']
+```
+
+An example of how to call the embeddings method is shown in this [get embeddings notebook](https://github.com/openai/openai-cookbook/blob/main/examples/Get_embeddings.ipynb).
+
+Examples of how to use embeddings are shared in the following Jupyter notebooks:
+
+- [Classification using embeddings](https://github.com/openai/openai-cookbook/blob/main/examples/Classification_using_embeddings.ipynb)
+- [Clustering using embeddings](https://github.com/openai/openai-cookbook/blob/main/examples/Clustering.ipynb)
+- [Code search using embeddings](https://github.com/openai/openai-cookbook/blob/main/examples/Code_search.ipynb)
+- [Semantic text search using embeddings](https://github.com/openai/openai-cookbook/blob/main/examples/Semantic_text_search_using_embeddings.ipynb)
+- [User and product embeddings](https://github.com/openai/openai-cookbook/blob/main/examples/User_and_product_embeddings.ipynb)
+- [Zero-shot classification using embeddings](https://github.com/openai/openai-cookbook/blob/main/examples/Zero-shot_classification_with_embeddings.ipynb)
+- [Recommendation using embeddings](https://github.com/openai/openai-cookbook/blob/main/examples/Recommendation_using_embeddings.ipynb)
+
+For more information on embeddings and the types of embeddings OpenAI offers, read the [embeddings guide](https://beta.openai.com/docs/guides/embeddings) in the OpenAI documentation.
+
+### Fine-tuning
+
+Fine-tuning a model on training data can both improve the results (by giving the model more examples to learn from) and reduce the cost/latency of API calls (chiefly through reducing the need to include training examples in prompts).
+
+Examples of fine-tuning are shared in the following Jupyter notebooks:
+
+- [Classification with fine-tuning](https://github.com/openai/openai-cookbook/blob/main/examples/Fine-tuned_classification.ipynb) (a simple notebook that shows the steps required for fine-tuning)
+- Fine-tuning a model that answers questions about the 2020 Olympics
+  - [Step 1: Collecting data](https://github.com/openai/openai-cookbook/blob/main/examples/fine-tuned_qa/olympics-1-collect-data.ipynb)
+  - [Step 2: Creating a synthetic Q&A dataset](https://github.com/openai/openai-cookbook/blob/main/examples/fine-tuned_qa/olympics-2-create-qa.ipynb)
+  - [Step 3: Train a fine-tuning model specialized for Q&A](https://github.com/openai/openai-cookbook/blob/main/examples/fine-tuned_qa/olympics-3-train-qa.ipynb)
+
+Sync your fine-tunes to [Weights & Biases](https://wandb.me/openai-docs) to track experiments, models, and datasets in your central dashboard with:
+
+```bash
+openai wandb sync
+```
+
+For more information on fine-tuning, read the [fine-tuning guide](https://beta.openai.com/docs/guides/fine-tuning) in the OpenAI documentation.
+
+### Moderation
+
+OpenAI provides a Moderation endpoint that can be used to check whether content complies with the OpenAI [content policy](https://platform.openai.com/docs/usage-policies)
+
+```python
+import openai
+openai.api_key = "sk-..."  # supply your API key however you choose
+
+moderation_resp = openai.Moderation.create(input="Here is some perfectly innocuous text that follows all OpenAI content policies.")
+```
+
+See the [moderation guide](https://platform.openai.com/docs/guides/moderation) for more details.
+
+## Image generation (DALL·E)
+
+```python
+import openai
+openai.api_key = "sk-..."  # supply your API key however you choose
+
+image_resp = openai.Image.create(prompt="two dogs playing chess, oil painting", n=4, size="512x512")
+
+```
+
+## Audio transcription (Whisper)
+
+```python
+import openai
+openai.api_key = "sk-..."  # supply your API key however you choose
+f = open("path/to/file.mp3", "rb")
+transcript = openai.Audio.transcribe("whisper-1", f)
+
+```
+
+## Async API
+
+Async support is available in the API by prepending `a` to a network-bound method:
+
+```python
+import openai
+openai.api_key = "sk-..."  # supply your API key however you choose
+
+async def create_chat_completion():
+    chat_completion_resp = await openai.ChatCompletion.acreate(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "Hello world"}])
+
+```
+
+To make async requests more efficient, you can pass in your own
+`aiohttp.ClientSession`, but you must manually close the client session at the end
+of your program/event loop:
+
+```python
+import openai
+from aiohttp import ClientSession
+
+openai.aiosession.set(ClientSession())
+# At the end of your program, close the http session
+await openai.aiosession.get().close()
+```
+
+See the [usage guide](https://platform.openai.com/docs/guides/images) for more details.
+
+## Requirements
+
+- Python 3.7.1+
+
+In general, we want to support the versions of Python that our
+customers are using. If you run into problems with any version
+issues, please let us know on our [support page](https://help.openai.com/en/).
+
+## Credit
+
+This library is forked from the [Stripe Python Library](https://github.com/stripe/stripe-python).

aibuildai-0.0.1.dist-info/RECORD

@@ -0,0 +1,61 @@
+aibuildai-0.0.1.dist-info/licenses/LICENSE,sha256=vLo94hSFHM5G7Vr0LWaYBEYW7qzoh8MjG8eiBHSrY54,1083
+openai/__init__.py,sha256=CaZOhi8F0Y9PAVhkKRhda0pQnzHbhIen6I-s6W1miEI,2759
+openai/_openai_scripts.py,sha256=KDA_8h9wIJqVpRBSM-_r3FOhi3S5Hh5b5zMzxIIoZ2s,2558
+openai/api_requestor.py,sha256=2q9qbzcIUBjI7DVG_TucEEK0nEh6qTQD9VkPIn7cm88,25865
+openai/cli.py,sha256=IL9L_7h4ZAxqnLnBgdD2MsQxNZsG-ZjMlpEtf-kH5Dw,38452
+openai/embeddings_utils.py,sha256=0LweljppFfBV5GjY_oipGTnVqpicnECqseKYJOX8tWM,8592
+openai/error.py,sha256=xJJSg_JWuEKL5WdASVg3wNx27J52tzXN9f86kPkCEII,4298
+openai/object_classes.py,sha256=yN2tqUdG1ATov5C1zt06cG1o_ad0o5qYfZlK4bso7eY,379
+openai/openai_object.py,sha256=AohBhBMUtdI96e0YBiiqMabG4ZbkcSYIN_q0LZVr_V8,10774
+openai/openai_response.py,sha256=GoWVZ5kKB0-p8hEN0_0v8TTOq4drthtNRivQc3VBrsk,836
+openai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openai/upload_progress.py,sha256=L723nchd5OQ_tfDFDKOru_rlHdG73uzesOh528wOOcM,1188
+openai/util.py,sha256=erOS0iwMOpjIUd1TH2clqXxdA-MU1ll0dC8cBP3DO9w,5366
+openai/validators.py,sha256=lqy0NTs1rZS7lt_DFKGtyOmhBVf5LwkmYchsiMKMkBA,34275
+openai/version.py,sha256=Q8raD6k02z4DoYniAz3iui5d6EdM1el95SMTLXJbeCA,18
+openai/wandb_logger.py,sha256=ZQpNHqwrru0sYXMyL9ywOOWS68OhKypoxko1Jko3CuQ,10388
+openai/api_resources/__init__.py,sha256=S5vOHXDRZu1kHikYR82kF5QUU4jEK7rMr2vEaoHQn20,907
+openai/api_resources/audio.py,sha256=HHXQEgzR00KFzl-hq-YyiurjPET9NELPs0AJ7TkrwWs,7050
+openai/api_resources/chat_completion.py,sha256=8mQ-UPp9FcJTMq2ae9nsTpLHnjEjSR7T788l-S6jQIQ,1587
+openai/api_resources/completion.py,sha256=EDgsMEJXwYyTqB5fGy2Vi6nQeproKZWvNmkdNve5Ykc,1610
+openai/api_resources/customer.py,sha256=vX1reXMqDHLssmT2aGev83TIE4NbnzvQ73yrQWyDpFk,539
+openai/api_resources/deployment.py,sha256=9K64JZyWxVcvutebf0qguYrSRPb0V_lMALwNsWRqNzs,4055
+openai/api_resources/edit.py,sha256=HlE11SFBBJH_ompIBHAYToNc4tIdUu01tZyym7f8LlE,1963
+openai/api_resources/embedding.py,sha256=iQBHiBszZPuh4lbiucL9mT_c9ed6DvPatHvyER4ye1Q,3438
+openai/api_resources/engine.py,sha256=_bzICgcNFmpdm08yL_W3n-vekkO0AGcCdPGl352HMT8,1665
+openai/api_resources/error_object.py,sha256=gKtXIo8mYZDPE2GiJUzQ8LDzLKKEPLqQoyYo_AAqOA4,892
+openai/api_resources/file.py,sha256=TX9xFoWeAtRAGyHUTJhcI3BnpQtZKHlAW35mT6fPrGQ,7737
+openai/api_resources/fine_tune.py,sha256=uotwurKyV8wAnyw4x01O2b2t3b--8i_EBSBVbV-2EhE,5263
+openai/api_resources/image.py,sha256=cwwVjOFRblykuBC9cLyLsmDBKmfkppF3gwTz2hF7Wgs,8341
+openai/api_resources/model.py,sha256=BiXo7j4P6-rhZW8my4eAbD6aIdQ6sAf2Dw9e-U21b_Q,169
+openai/api_resources/moderation.py,sha256=XLEVJbP2A5AqcnelbIcXq7-PMqvfPPibOetOf2xiMTA,1376
+openai/api_resources/abstract/__init__.py,sha256=ZUZv2MkEpRUeRZ0NtRHczXNAamFTUK17z87O3WpXzLQ,540
+openai/api_resources/abstract/api_resource.py,sha256=wzCww3boKgr0Ru33CIRi8lOCsMEtQJLKlz1HMHIpMkY,5443
+openai/api_resources/abstract/createable_api_resource.py,sha256=w6atKaf0aUDe3NuV-wLtbmCxCGPtCxXIkH98yk8s7xQ,2573
+openai/api_resources/abstract/deletable_api_resource.py,sha256=9jI4tt7RejbO0aIyLJwivyg3jclr7r55-l50mVFC7GI,1624
+openai/api_resources/abstract/engine_api_resource.py,sha256=GGj9NpJkPqKozgTT3E2meIS1VsRq8YnTg_A3Uzh-P00,10007
+openai/api_resources/abstract/listable_api_resource.py,sha256=-okp69Lu1OaA9aIkEK2nC-JXRW44vtCKFCN89w_4f60,2678
+openai/api_resources/abstract/nested_resource_class_methods.py,sha256=7rCNmuZhLgbN7M6PcNT-P9W5taHFZF-ObDYXz7GLFuI,5086
+openai/api_resources/abstract/updateable_api_resource.py,sha256=cQQd04fI85DTYpOqM_LFuZ9ldDKrkT-MRetkDG5FUU0,534
+openai/api_resources/experimental/__init__.py,sha256=fLUruA1uO11wqsDNuAKxgx3qVhQyPYC79JoZNTCIq1A,104
+openai/api_resources/experimental/completion_config.py,sha256=7vlxmFIkpleNCEUir50NBk31XxnqL0yBFZ5Ah1h9TpQ,274
+openai/datalib/__init__.py,sha256=cCLTzxxXF1mYb_iC2zX9WMr_VnJWnuWOPxgFvLZKIYE,651
+openai/datalib/common.py,sha256=YNnJ_IDOc-lF43LkwFJNftfF5h2n9mhdt6eZfAH976w,258
+openai/datalib/numpy_helper.py,sha256=p5o-NYEF0DX5jN9Dy_pRbYpD9M9C1B18konK-WZSOIQ,320
+openai/datalib/pandas_helper.py,sha256=WvA3nHCaTgeB5-VgSJlfqfQzVMdmi_hKFRQtamdLzAE,329
+openai/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openai/tests/test_api_requestor.py,sha256=rU9EJyDrtOqSzDmMaYxf-FKqdaBCFHkzJYGMCQS37EY,3582
+openai/tests/test_endpoints.py,sha256=RgYp2Gcz-nkM6AH35MJ_QvNKcpN5IUvIzMth7SzsJN4,2867
+openai/tests/test_exceptions.py,sha256=VbKHyi7QAoLi_t6IMuJWSdSkY4zJD4ngrNRjQ89GIjQ,1156
+openai/tests/test_file_cli.py,sha256=BIBCaDJ6SZsAtvNqERhEQLDutJjoejgV9GCP3tYcu1A,1418
+openai/tests/test_long_examples_validator.py,sha256=hlJSur4VkHxc3kMviBMeuZTATyEqwHCDdCTD0ok_v1g,2016
+openai/tests/test_url_composition.py,sha256=d3Jr-bmCFLedEYu3FTYN180WT6wBygRABW8g9R3ccsA,6506
+openai/tests/test_util.py,sha256=K268icrNV6XQBi25VSGqpBzOP2bLBoIuSj91NMV4nU0,1786
+openai/tests/asyncio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openai/tests/asyncio/test_endpoints.py,sha256=ko3ra_FcwlmkCzxEoVwIyOTYdSNQn7VgSqUGQ7O8kro,2362
+aibuildai-0.0.1.dist-info/METADATA,sha256=in1hcnb86ra1KEbvj9k-7Src_S_9Y-hOGgRGnp3bctw,13891
+aibuildai-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+aibuildai-0.0.1.dist-info/entry_points.txt,sha256=q68fD1MsMkiejaG68n2mKmbuZEwWkq89oniOBBq9fo0,55
+aibuildai-0.0.1.dist-info/top_level.txt,sha256=yroxRDiE4kOdI0tEpF1d7ffoQJMxe4i3z_pKoyou9wg,7
+aibuildai-0.0.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+aibuildai-0.0.1.dist-info/RECORD,,

aibuildai-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aibuildai-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+openai = openai._openai_scripts:main

aibuildai-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) OpenAI (https://openai.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

aibuildai-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+openai

aibuildai-0.0.1.dist-info/zip-safe

@@ -0,0 +1 @@
+

openai/__init__.py

@@ -0,0 +1,104 @@
+# OpenAI Python bindings.
+#
+# Originally forked from the MIT-licensed Stripe Python bindings.
+
+import os
+import sys
+from typing import TYPE_CHECKING, Optional, Union, Callable
+
+from contextvars import ContextVar
+
+if "pkg_resources" not in sys.modules:
+    # workaround for the following:
+    # https://github.com/benoitc/gunicorn/pull/2539
+    sys.modules["pkg_resources"] = object()  # type: ignore[assignment]
+    import aiohttp
+
+    del sys.modules["pkg_resources"]
+
+from openai.api_resources import (
+    Audio,
+    ChatCompletion,
+    Completion,
+    Customer,
+    Deployment,
+    Edit,
+    Embedding,
+    Engine,
+    ErrorObject,
+    File,
+    FineTune,
+    Image,
+    Model,
+    Moderation,
+)
+from openai.error import APIError, InvalidRequestError, OpenAIError
+from openai.version import VERSION
+
+if TYPE_CHECKING:
+    import requests
+    from aiohttp import ClientSession
+
+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 = os.environ.get(
+    "OPENAI_API_VERSION",
+    ("2023-05-15" 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
+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
+
+requestssession: Optional[
+    Union["requests.Session", Callable[[], "requests.Session"]]
+] = None # Provide a requests.Session or Session factory.
+
+aiosession: ContextVar[Optional["ClientSession"]] = ContextVar(
+    "aiohttp-session", default=None
+)  # Acts as a global aiohttp ClientSession that reuses connections.
+# This is user-supplied; otherwise, a session is remade for each request.
+
+__version__ = VERSION
+__all__ = [
+    "APIError",
+    "Audio",
+    "ChatCompletion",
+    "Completion",
+    "Customer",
+    "Edit",
+    "Image",
+    "Deployment",
+    "Embedding",
+    "Engine",
+    "ErrorObject",
+    "File",
+    "FineTune",
+    "InvalidRequestError",
+    "Model",
+    "Moderation",
+    "OpenAIError",
+    "api_base",
+    "api_key",
+    "api_type",
+    "api_key_path",
+    "api_version",
+    "app_info",
+    "ca_bundle_path",
+    "debug",
+    "enable_telemetry",
+    "log",
+    "organization",
+    "proxy",
+    "verify_ssl_certs",
+]

openai/_openai_scripts.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+import argparse
+import logging
+import sys
+
+import openai
+from openai import version
+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",
+        "--version",
+        action="version",
+        version="%(prog)s " + version.VERSION,
+    )
+    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("-p", "--proxy", nargs='+', help="What proxy 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
+    if args.proxy is not None:
+        openai.proxy = {}
+        for proxy in args.proxy:
+            if proxy.startswith('https'):
+                openai.proxy['https'] = proxy
+            elif proxy.startswith('http'):
+                openai.proxy['http'] = proxy
+
+    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())