{ "mode": "pydoc", "parameter": "openai", "section": "", "url": "https://www.chedong.com/phpMan.php/pydoc/openai/json", "generated": "2026-07-19T01:17:39Z", "sections": { "NAME": { "content": "openai - # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.\n", "subsections": [] }, "PACKAGE CONTENTS": { "content": "baseclient\nclient\ncompat\nconstants\neventhandler\nexceptions\nextras (package)\nfiles\nlegacyresponse\nmodels\nmoduleclient\nprovider\nqs\nresource\nresponse\nsendqueue\nstreaming\ntypes\nutils (package)\nversion\nauth (package)\nhelpers (package)\nlib (package)\npagination\nproviders (package)\nresources (package)\ntypes (package)\nversion\n", "subsections": [] }, "SUBMODULES": { "content": "azure\nbedrock\n", "subsections": [] }, "CLASSES": { "content": "builtins.Exception(builtins.BaseException)\nOpenAIError\nAPIError\nAPIConnectionError\nAPITimeoutError\nAPIResponseValidationError\nAPIStatusError\nAuthenticationError\nOAuthError\nBadRequestError\nConflictError\nInternalServerError\nNotFoundError\nPermissionDeniedError\nRateLimitError\nUnprocessableEntityError\nContentFilterFinishReasonError\nLengthFinishReasonError\nWebSocketConnectionClosedError\nWebSocketQueueFullError\nbuiltins.ValueError(builtins.Exception)\nInvalidWebhookSignatureError\nbuiltins.dict(builtins.object)\nReconnectingOverrides\nRequestOptions\nbuiltins.object\nbuiltins.NoneType\nBaseTransport\nNotGiven\nOmit\nReconnectingEvent\nTimeout\nhttpx.AsyncClient(httpx.client.BaseClient)\nDefaultAioHttpClient\nDefaultAsyncHttpxClient\nhttpx.Client(httpx.client.BaseClient)\nDefaultHttpxClient\nopenai.baseclient.AsyncAPIClient(openai.baseclient.BaseClient)\nAsyncOpenAI\nAsyncBedrockOpenAI\nopenai.baseclient.SyncAPIClient(openai.baseclient.BaseClient)\nOpenAI\nBedrockOpenAI\npydantic.main.BaseModel(builtins.object)\nBaseModel\ntyping.Generic(builtins.object)\nAsyncStream\nStream\n", "subsections": [ { "name": "class APIConnectionError", "content": "| APIConnectionError(*, message: 'str' = 'Connection error.', request: 'httpx.Request') -> 'None'\n|\n| Method resolution order:\n| APIConnectionError\n| APIError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, *, message: 'str' = 'Connection error.', request: 'httpx.Request') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {}\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from APIError:\n|\n| code = None\n|\n| param = None\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class APIError", "content": "| APIError(message: 'str', request: 'httpx.Request', *, body: 'object | None') -> 'None'\n|\n| Method resolution order:\n| APIError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, message: 'str', request: 'httpx.Request', *, body: 'object | None') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {'body': 'object | None', 'code': 'Optional[str]', '...\n|\n| code = None\n|\n| param = None\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class APIResponseValidationError", "content": "| APIResponseValidationError(response: 'httpx.Response', body: 'object | None', *, message: 'str | None' = None) -> 'None'\n|\n| Method resolution order:\n| APIResponseValidationError\n| APIError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, response: 'httpx.Response', body: 'object | None', *, message: 'str | None' = None) -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {'response': 'httpx.Response', 'statuscode': 'int'}\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from APIError:\n|\n| code = None\n|\n| param = None\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class APIStatusError", "content": "| APIStatusError(message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n|\n| Raised when an API response has a status code of 4xx or 5xx.\n|\n| Method resolution order:\n| APIStatusError\n| APIError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {'requestid': 'str | None', 'response': 'httpx.Resp...\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from APIError:\n|\n| code = None\n|\n| param = None\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class APITimeoutError", "content": "| APITimeoutError(request: 'httpx.Request') -> 'None'\n|\n| Method resolution order:\n| APITimeoutError\n| APIConnectionError\n| APIError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, request: 'httpx.Request') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {}\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from APIError:\n|\n| code = None\n|\n| param = None\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class AsyncBedrockOpenAI", "content": "| AsyncBedrockOpenAI(*, apikey: 'str | None' = None, bedrocktokenprovider: 'AsyncBedrockTokenProvider | None' = None, awsregion: 'str | None' = None, awsprofile: 'str | None' = None, awsaccesskeyid: 'str | None' = None, awssecretaccesskey: 'str | None' = None, awssessiontoken: 'str | None' = None, awscredentialsprovider: 'AwsCredentialsProvider | None' = None, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, baseurl: 'str | httpx.URL | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, maxretries: 'int' = 2, defaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, httpclient: 'httpx.AsyncClient | None' = None, strictresponsevalidation: 'bool' = False, enforcecredentials: 'bool' = True, provider: 'Provider | None' = None, state: 'LegacyBedrockState | None' = None, regionwasexplicit: 'bool | None' = None) -> 'None'\n|\n| Async compatibility client for Amazon Bedrock's OpenAI-compatible endpoint.\n|\n| Method resolution order:\n| AsyncBedrockOpenAI\n| AsyncOpenAI\n| openai.baseclient.AsyncAPIClient\n| openai.baseclient.BaseClient\n| typing.Generic\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, *, apikey: 'str | None' = None, bedrocktokenprovider: 'AsyncBedrockTokenProvider | None' = None, awsregion: 'str | None' = None, awsprofile: 'str | None' = None, awsaccesskeyid: 'str | None' = None, awssecretaccesskey: 'str | None' = None, awssessiontoken: 'str | None' = None, awscredentialsprovider: 'AwsCredentialsProvider | None' = None, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, baseurl: 'str | httpx.URL | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, maxretries: 'int' = 2, defaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, httpclient: 'httpx.AsyncClient | None' = None, strictresponsevalidation: 'bool' = False, enforcecredentials: 'bool' = True, provider: 'Provider | None' = None, state: 'LegacyBedrockState | None' = None, regionwasexplicit: 'bool | None' = None) -> 'None'\n| Construct a new async AsyncOpenAI client instance.\n|\n| This automatically infers the following arguments from their corresponding environment variables if they are not provided:\n| - `apikey` from `OPENAIAPIKEY`\n| - `adminapikey` from `OPENAIADMINKEY`\n| - `organization` from `OPENAIORGID`\n| - `project` from `OPENAIPROJECTID`\n| - `webhooksecret` from `OPENAIWEBHOOKSECRET`\n|\n| When `provider` is supplied, authentication and the base URL are configured by that provider instead.\n|\n| copy(self, *, apikey: 'str | AsyncBedrockTokenProvider | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, provider: 'Provider | None | NotGiven' = NOTGIVEN, bedrocktokenprovider: 'AsyncBedrockTokenProvider | None' = None, awsregion: 'str | None' = None, awsprofile: 'str | None' = None, awsaccesskeyid: 'str | None' = None, awssecretaccesskey: 'str | None' = None, awssessiontoken: 'str | None' = None, awscredentialsprovider: 'AwsCredentialsProvider | None' = None, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, baseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, httpclient: 'httpx.AsyncClient | None' = None, maxretries: 'int | NotGiven' = NOTGIVEN, defaultheaders: 'Mapping[str, str] | None' = None, setdefaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, setdefaultquery: 'Mapping[str, object] | None' = None, enforcecredentials: 'bool | None' = None, extrakwargs: 'Mapping[str, Any]' = {}) -> 'Self'\n| Create a new client instance re-using the same options given to the current client with optional overriding.\n|\n| withoptions = copy(self, *, apikey: 'str | AsyncBedrockTokenProvider | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, provider: 'Provider | None | NotGiven' = NOTGIVEN, bedrocktokenprovider: 'AsyncBedrockTokenProvider | None' = None, awsregion: 'str | None' = None, awsprofile: 'str | None' = None, awsaccesskeyid: 'str | None' = None, awssecretaccesskey: 'str | None' = None, awssessiontoken: 'str | None' = None, awscredentialsprovider: 'AwsCredentialsProvider | None' = None, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, baseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, httpclient: 'httpx.AsyncClient | None' = None, maxretries: 'int | NotGiven' = NOTGIVEN, defaultheaders: 'Mapping[str, str] | None' = None, setdefaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, setdefaultquery: 'Mapping[str, object] | None' = None, enforcecredentials: 'bool | None' = None, extrakwargs: 'Mapping[str, Any]' = {}) -> 'Self'\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {'bedrockprovider': 'Provider', 'bedrockruntime...\n|\n| parameters = ()\n|\n| ----------------------------------------------------------------------\n| Methods inherited from AsyncOpenAI:\n|\n| admin = \n| audio = \n| batches = \n| Create large batches of API requests to run asynchronously.\n|\n| beta = \n| chat = \n| completions = \n| Given a prompt, the model will return one or more predicted completions, and can also return the probabilities of alternative tokens at each position.\n|\n| containers = \n| conversations = \n| Manage conversations and conversation items.\n|\n| embeddings = \n| Get a vector representation of a given input that can be easily consumed by machine learning models and algorithms.\n|\n| evals = \n| Manage and run evals in the OpenAI platform.\n|\n| files = \n| Files are used to upload documents that can be used with features like Assistants and Fine-tuning.\n|\n| finetuning = \n| images = \n| Given a prompt and/or an input image, the model will generate a new image.\n|\n| models = \n| List and describe the various models available in the API.\n|\n| moderations = \n| Given text and/or image inputs, classifies if those inputs are potentially harmful.\n|\n| realtime = \n| responses = \n| skills = \n| uploads = \n| Use Uploads to upload large files in multiple parts.\n|\n| vectorstores = \n| videos = \n| webhooks = \n| withrawresponse = \n| withstreamingresponse = \n| ----------------------------------------------------------------------\n| Readonly properties inherited from AsyncOpenAI:\n|\n| authheaders\n|\n| customauth\n|\n| defaultheaders\n|\n| qs\n|\n| ----------------------------------------------------------------------\n| Methods inherited from openai.baseclient.AsyncAPIClient:\n|\n| async aenter(self: 'T') -> 'T'\n|\n| async aexit(self, exctype: 'type[BaseException] | None', exc: 'BaseException | None', exctb: 'TracebackType | None') -> 'None'\n|\n| async close(self) -> 'None'\n| Close the underlying HTTPX client.\n|\n| The client will *not* be usable after this.\n|\n| async delete(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'AsyncBinaryTypes | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| async get(self, path: 'str', *, castto: 'Type[ResponseT]', options: 'RequestOptions' = {}, stream: 'bool' = False, streamcls: 'type[AsyncStreamT] | None' = None) -> 'ResponseT | AsyncStreamT'\n|\n| getapilist(self, path: 'str', *, model: 'Type[T]', page: 'Type[AsyncPageT]', body: 'Body | None' = None, options: 'RequestOptions' = {}, method: 'str' = 'get') -> 'AsyncPaginator[T, AsyncPageT]'\n|\n| isclosed(self) -> 'bool'\n|\n| async patch(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'AsyncBinaryTypes | None' = None, files: 'RequestFiles | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| async post(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'AsyncBinaryTypes | None' = None, files: 'RequestFiles | None' = None, options: 'RequestOptions' = {}, stream: 'bool' = False, streamcls: 'type[AsyncStreamT] | None' = None) -> 'ResponseT | AsyncStreamT'\n|\n| async put(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'AsyncBinaryTypes | None' = None, files: 'RequestFiles | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| async request(self, castto: 'Type[ResponseT]', options: 'FinalRequestOptions', *, stream: 'bool' = False, streamcls: 'type[AsyncStreamT] | None' = None) -> 'ResponseT | AsyncStreamT'\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from openai.baseclient.AsyncAPIClient:\n|\n| origbases = (openai.baseclient.BaseClient[httpx.AsyncClient, op...\n|\n| ----------------------------------------------------------------------\n| Methods inherited from openai.baseclient.BaseClient:\n|\n| platformheaders(self) -> 'Dict[str, str]'\n|\n| ----------------------------------------------------------------------\n| Readonly properties inherited from openai.baseclient.BaseClient:\n|\n| defaultquery\n|\n| useragent\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from openai.baseclient.BaseClient:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| baseurl\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from typing.Generic:\n|\n| classgetitem(params) from builtins.type\n|\n| initsubclass(*args, kwargs) from builtins.type\n| This method is called when a class is subclassed.\n|\n| The default implementation does nothing. It may be\n| overridden to extend subclasses.\n\nAsyncClient = class AsyncOpenAI(openai.baseclient.AsyncAPIClient)\n| AsyncClient(*, apikey: 'str | Callable[[], Awaitable[str]] | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, provider: 'Provider | None' = None, baseurl: 'str | httpx.URL | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, maxretries: 'int' = 2, defaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, httpclient: 'httpx.AsyncClient | None' = None, strictresponsevalidation: 'bool' = False, enforcecredentials: 'bool' = True) -> 'None'\n|\n| Method resolution order:\n| AsyncOpenAI\n| openai.baseclient.AsyncAPIClient\n| openai.baseclient.BaseClient\n| typing.Generic\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, *, apikey: 'str | Callable[[], Awaitable[str]] | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, provider: 'Provider | None' = None, baseurl: 'str | httpx.URL | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, maxretries: 'int' = 2, defaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, httpclient: 'httpx.AsyncClient | None' = None, strictresponsevalidation: 'bool' = False, enforcecredentials: 'bool' = True) -> 'None'\n| Construct a new async AsyncOpenAI client instance.\n|\n| This automatically infers the following arguments from their corresponding environment variables if they are not provided:\n| - `apikey` from `OPENAIAPIKEY`\n| - `adminapikey` from `OPENAIADMINKEY`\n| - `organization` from `OPENAIORGID`\n| - `project` from `OPENAIPROJECTID`\n| - `webhooksecret` from `OPENAIWEBHOOKSECRET`\n|\n| When `provider` is supplied, authentication and the base URL are configured by that provider instead.\n|\n| admin = \n| audio = \n| batches = \n| Create large batches of API requests to run asynchronously.\n|\n| beta = \n| chat = \n| completions = \n| Given a prompt, the model will return one or more predicted completions, and can also return the probabilities of alternative tokens at each position.\n|\n| containers = \n| conversations = \n| Manage conversations and conversation items.\n|\n| copy(self, *, apikey: 'str | Callable[[], Awaitable[str]] | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, provider: 'Provider | None | NotGiven' = NOTGIVEN, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, baseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, httpclient: 'httpx.AsyncClient | None' = None, maxretries: 'int | NotGiven' = NOTGIVEN, defaultheaders: 'Mapping[str, str] | None' = None, setdefaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, setdefaultquery: 'Mapping[str, object] | None' = None, enforcecredentials: 'bool | None' = None, extrakwargs: 'Mapping[str, Any]' = {}) -> 'Self'\n| Create a new client instance re-using the same options given to the current client with optional overriding.\n|\n| embeddings = \n| Get a vector representation of a given input that can be easily consumed by machine learning models and algorithms.\n|\n| evals = \n| Manage and run evals in the OpenAI platform.\n|\n| files = \n| Files are used to upload documents that can be used with features like Assistants and Fine-tuning.\n|\n| finetuning = \n| images = \n| Given a prompt and/or an input image, the model will generate a new image.\n|\n| models = \n| List and describe the various models available in the API.\n|\n| moderations = \n| Given text and/or image inputs, classifies if those inputs are potentially harmful.\n|\n| realtime = \n| responses = \n| skills = \n| uploads = \n| Use Uploads to upload large files in multiple parts.\n|\n| vectorstores = \n| videos = \n| webhooks = \n| withoptions = copy(self, *, apikey: 'str | Callable[[], Awaitable[str]] | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, provider: 'Provider | None | NotGiven' = NOTGIVEN, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, baseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, httpclient: 'httpx.AsyncClient | None' = None, maxretries: 'int | NotGiven' = NOTGIVEN, defaultheaders: 'Mapping[str, str] | None' = None, setdefaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, setdefaultquery: 'Mapping[str, object] | None' = None, enforcecredentials: 'bool | None' = None, extrakwargs: 'Mapping[str, Any]' = {}) -> 'Self'\n|\n| withrawresponse = \n| withstreamingresponse = \n| ----------------------------------------------------------------------\n| Readonly properties defined here:\n|\n| authheaders\n|\n| customauth\n|\n| defaultheaders\n|\n| qs\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {'provider': 'Provider | None', 'providerruntime...\n|\n| parameters = ()\n|\n| ----------------------------------------------------------------------\n| Methods inherited from openai.baseclient.AsyncAPIClient:\n|\n| async aenter(self: 'T') -> 'T'\n|\n| async aexit(self, exctype: 'type[BaseException] | None', exc: 'BaseException | None', exctb: 'TracebackType | None') -> 'None'\n|\n| async close(self) -> 'None'\n| Close the underlying HTTPX client.\n|\n| The client will *not* be usable after this.\n|\n| async delete(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'AsyncBinaryTypes | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| async get(self, path: 'str', *, castto: 'Type[ResponseT]', options: 'RequestOptions' = {}, stream: 'bool' = False, streamcls: 'type[AsyncStreamT] | None' = None) -> 'ResponseT | AsyncStreamT'\n|\n| getapilist(self, path: 'str', *, model: 'Type[T]', page: 'Type[AsyncPageT]', body: 'Body | None' = None, options: 'RequestOptions' = {}, method: 'str' = 'get') -> 'AsyncPaginator[T, AsyncPageT]'\n|\n| isclosed(self) -> 'bool'\n|\n| async patch(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'AsyncBinaryTypes | None' = None, files: 'RequestFiles | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| async post(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'AsyncBinaryTypes | None' = None, files: 'RequestFiles | None' = None, options: 'RequestOptions' = {}, stream: 'bool' = False, streamcls: 'type[AsyncStreamT] | None' = None) -> 'ResponseT | AsyncStreamT'\n|\n| async put(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'AsyncBinaryTypes | None' = None, files: 'RequestFiles | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| async request(self, castto: 'Type[ResponseT]', options: 'FinalRequestOptions', *, stream: 'bool' = False, streamcls: 'type[AsyncStreamT] | None' = None) -> 'ResponseT | AsyncStreamT'\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from openai.baseclient.AsyncAPIClient:\n|\n| origbases = (openai.baseclient.BaseClient[httpx.AsyncClient, op...\n|\n| ----------------------------------------------------------------------\n| Methods inherited from openai.baseclient.BaseClient:\n|\n| platformheaders(self) -> 'Dict[str, str]'\n|\n| ----------------------------------------------------------------------\n| Readonly properties inherited from openai.baseclient.BaseClient:\n|\n| defaultquery\n|\n| useragent\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from openai.baseclient.BaseClient:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| baseurl\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from typing.Generic:\n|\n| classgetitem(params) from builtins.type\n|\n| initsubclass(*args, kwargs) from builtins.type\n| This method is called when a class is subclassed.\n|\n| The default implementation does nothing. It may be\n| overridden to extend subclasses.\n" }, { "name": "class AsyncOpenAI", "content": "| AsyncOpenAI(*, apikey: 'str | Callable[[], Awaitable[str]] | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, provider: 'Provider | None' = None, baseurl: 'str | httpx.URL | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, maxretries: 'int' = 2, defaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, httpclient: 'httpx.AsyncClient | None' = None, strictresponsevalidation: 'bool' = False, enforcecredentials: 'bool' = True) -> 'None'\n|\n| Method resolution order:\n| AsyncOpenAI\n| openai.baseclient.AsyncAPIClient\n| openai.baseclient.BaseClient\n| typing.Generic\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, *, apikey: 'str | Callable[[], Awaitable[str]] | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, provider: 'Provider | None' = None, baseurl: 'str | httpx.URL | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, maxretries: 'int' = 2, defaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, httpclient: 'httpx.AsyncClient | None' = None, strictresponsevalidation: 'bool' = False, enforcecredentials: 'bool' = True) -> 'None'\n| Construct a new async AsyncOpenAI client instance.\n|\n| This automatically infers the following arguments from their corresponding environment variables if they are not provided:\n| - `apikey` from `OPENAIAPIKEY`\n| - `adminapikey` from `OPENAIADMINKEY`\n| - `organization` from `OPENAIORGID`\n| - `project` from `OPENAIPROJECTID`\n| - `webhooksecret` from `OPENAIWEBHOOKSECRET`\n|\n| When `provider` is supplied, authentication and the base URL are configured by that provider instead.\n|\n| admin = \n| audio = \n| batches = \n| Create large batches of API requests to run asynchronously.\n|\n| beta = \n| chat = \n| completions = \n| Given a prompt, the model will return one or more predicted completions, and can also return the probabilities of alternative tokens at each position.\n|\n| containers = \n| conversations = \n| Manage conversations and conversation items.\n|\n| copy(self, *, apikey: 'str | Callable[[], Awaitable[str]] | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, provider: 'Provider | None | NotGiven' = NOTGIVEN, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, baseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, httpclient: 'httpx.AsyncClient | None' = None, maxretries: 'int | NotGiven' = NOTGIVEN, defaultheaders: 'Mapping[str, str] | None' = None, setdefaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, setdefaultquery: 'Mapping[str, object] | None' = None, enforcecredentials: 'bool | None' = None, extrakwargs: 'Mapping[str, Any]' = {}) -> 'Self'\n| Create a new client instance re-using the same options given to the current client with optional overriding.\n|\n| embeddings = \n| Get a vector representation of a given input that can be easily consumed by machine learning models and algorithms.\n|\n| evals = \n| Manage and run evals in the OpenAI platform.\n|\n| files = \n| Files are used to upload documents that can be used with features like Assistants and Fine-tuning.\n|\n| finetuning = \n| images = \n| Given a prompt and/or an input image, the model will generate a new image.\n|\n| models = \n| List and describe the various models available in the API.\n|\n| moderations = \n| Given text and/or image inputs, classifies if those inputs are potentially harmful.\n|\n| realtime = \n| responses = \n| skills = \n| uploads = \n| Use Uploads to upload large files in multiple parts.\n|\n| vectorstores = \n| videos = \n| webhooks = \n| withoptions = copy(self, *, apikey: 'str | Callable[[], Awaitable[str]] | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, provider: 'Provider | None | NotGiven' = NOTGIVEN, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, baseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, httpclient: 'httpx.AsyncClient | None' = None, maxretries: 'int | NotGiven' = NOTGIVEN, defaultheaders: 'Mapping[str, str] | None' = None, setdefaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, setdefaultquery: 'Mapping[str, object] | None' = None, enforcecredentials: 'bool | None' = None, extrakwargs: 'Mapping[str, Any]' = {}) -> 'Self'\n|\n| withrawresponse = \n| withstreamingresponse = \n| ----------------------------------------------------------------------\n| Readonly properties defined here:\n|\n| authheaders\n|\n| customauth\n|\n| defaultheaders\n|\n| qs\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {'provider': 'Provider | None', 'providerruntime...\n|\n| parameters = ()\n|\n| ----------------------------------------------------------------------\n| Methods inherited from openai.baseclient.AsyncAPIClient:\n|\n| async aenter(self: 'T') -> 'T'\n|\n| async aexit(self, exctype: 'type[BaseException] | None', exc: 'BaseException | None', exctb: 'TracebackType | None') -> 'None'\n|\n| async close(self) -> 'None'\n| Close the underlying HTTPX client.\n|\n| The client will *not* be usable after this.\n|\n| async delete(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'AsyncBinaryTypes | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| async get(self, path: 'str', *, castto: 'Type[ResponseT]', options: 'RequestOptions' = {}, stream: 'bool' = False, streamcls: 'type[AsyncStreamT] | None' = None) -> 'ResponseT | AsyncStreamT'\n|\n| getapilist(self, path: 'str', *, model: 'Type[T]', page: 'Type[AsyncPageT]', body: 'Body | None' = None, options: 'RequestOptions' = {}, method: 'str' = 'get') -> 'AsyncPaginator[T, AsyncPageT]'\n|\n| isclosed(self) -> 'bool'\n|\n| async patch(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'AsyncBinaryTypes | None' = None, files: 'RequestFiles | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| async post(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'AsyncBinaryTypes | None' = None, files: 'RequestFiles | None' = None, options: 'RequestOptions' = {}, stream: 'bool' = False, streamcls: 'type[AsyncStreamT] | None' = None) -> 'ResponseT | AsyncStreamT'\n|\n| async put(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'AsyncBinaryTypes | None' = None, files: 'RequestFiles | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| async request(self, castto: 'Type[ResponseT]', options: 'FinalRequestOptions', *, stream: 'bool' = False, streamcls: 'type[AsyncStreamT] | None' = None) -> 'ResponseT | AsyncStreamT'\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from openai.baseclient.AsyncAPIClient:\n|\n| origbases = (openai.baseclient.BaseClient[httpx.AsyncClient, op...\n|\n| ----------------------------------------------------------------------\n| Methods inherited from openai.baseclient.BaseClient:\n|\n| platformheaders(self) -> 'Dict[str, str]'\n|\n| ----------------------------------------------------------------------\n| Readonly properties inherited from openai.baseclient.BaseClient:\n|\n| defaultquery\n|\n| useragent\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from openai.baseclient.BaseClient:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| baseurl\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from typing.Generic:\n|\n| classgetitem(params) from builtins.type\n|\n| initsubclass(*args, kwargs) from builtins.type\n| This method is called when a class is subclassed.\n|\n| The default implementation does nothing. It may be\n| overridden to extend subclasses.\n" }, { "name": "class AsyncStream", "content": "| AsyncStream(*, castto: 'type[T]', response: 'httpx.Response', client: 'AsyncOpenAI', options: 'Optional[FinalRequestOptions]' = None) -> 'None'\n|\n| Provides the core interface to iterate over an asynchronous stream response.\n|\n| Method resolution order:\n| AsyncStream\n| typing.Generic\n| builtins.object\n|\n| Methods defined here:\n|\n| async aenter(self) -> 'Self'\n|\n| async aexit(self, exctype: 'type[BaseException] | None', exc: 'BaseException | None', exctb: 'TracebackType | None') -> 'None'\n|\n| async aiter(self) -> 'AsyncIterator[T]'\n|\n| async anext(self) -> 'T'\n|\n| init(self, *, castto: 'type[T]', response: 'httpx.Response', client: 'AsyncOpenAI', options: 'Optional[FinalRequestOptions]' = None) -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| async stream(self) -> 'AsyncIterator[T]'\n|\n| async close(self) -> 'None'\n| Close the response and release the connection.\n|\n| Automatically called if the response body is read to completion.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {'decoder': 'SSEDecoder | SSEBytesDecoder', 'optio...\n|\n| origbases = (typing.Generic[~T],)\n|\n| parameters = (~T,)\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from typing.Generic:\n|\n| classgetitem(params) from builtins.type\n|\n| initsubclass(*args, kwargs) from builtins.type\n| This method is called when a class is subclassed.\n|\n| The default implementation does nothing. It may be\n| overridden to extend subclasses.\n" }, { "name": "class AuthenticationError", "content": "| AuthenticationError(message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n|\n| Method resolution order:\n| AuthenticationError\n| APIStatusError\n| APIError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data and other attributes defined here:\n|\n| annotations = {'statuscode': 'Literal[401]'}\n|\n| statuscode = 401\n|\n| ----------------------------------------------------------------------\n| Methods inherited from APIStatusError:\n|\n| init(self, message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from APIError:\n|\n| code = None\n|\n| param = None\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class BadRequestError", "content": "| BadRequestError(message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n|\n| Method resolution order:\n| BadRequestError\n| APIStatusError\n| APIError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data and other attributes defined here:\n|\n| annotations = {'statuscode': 'Literal[400]'}\n|\n| statuscode = 400\n|\n| ----------------------------------------------------------------------\n| Methods inherited from APIStatusError:\n|\n| init(self, message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from APIError:\n|\n| code = None\n|\n| param = None\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class BaseModel", "content": "| BaseModel(data: 'Any') -> 'None'\n|\n| Method resolution order:\n| BaseModel\n| pydantic.main.BaseModel\n| builtins.object\n|\n| Methods defined here:\n|\n| str(self) -> 'str'\n| Return str(self).\n|\n| todict(self, *, mode: \"Literal['json', 'python']\" = 'python', useapinames: 'bool' = True, excludeunset: 'bool' = True, excludedefaults: 'bool' = False, excludenone: 'bool' = False, warnings: 'bool' = True) -> 'dict[str, object]'\n| Recursively generate a dictionary representation of the model, optionally specifying which fields to include or exclude.\n|\n| By default, fields that were not set by the API will not be included,\n| and keys will match the API response, *not* the property names from the model.\n|\n| For example, if the API responds with `\"fooBar\": true` but we've defined a `foobar: bool` property,\n| the output will use the `\"fooBar\"` key (unless `useapinames=False` is passed).\n|\n| Args:\n| mode:\n| If mode is 'json', the dictionary will only contain JSON serializable types. e.g. `datetime` will be turned into a string, `\"2024-3-22T18:11:19.117000Z\"`.\n| If mode is 'python', the dictionary may contain any Python objects. e.g. `datetime(2024, 3, 22)`\n|\n| useapinames: Whether to use the key that the API responded with or the property name. Defaults to `True`.\n| excludeunset: Whether to exclude fields that have not been explicitly set.\n| excludedefaults: Whether to exclude fields that are set to their default value from the output.\n| excludenone: Whether to exclude fields that have a value of `None` from the output.\n| warnings: Whether to log warnings when invalid fields are encountered. This is only supported in Pydantic v2.\n|\n| tojson(self, *, indent: 'int | None' = 2, useapinames: 'bool' = True, excludeunset: 'bool' = True, excludedefaults: 'bool' = False, excludenone: 'bool' = False, warnings: 'bool' = True) -> 'str'\n| Generates a JSON string representing this model as it would be received from or sent to the API (but with indentation).\n|\n| By default, fields that were not set by the API will not be included,\n| and keys will match the API response, *not* the property names from the model.\n|\n| For example, if the API responds with `\"fooBar\": true` but we've defined a `foobar: bool` property,\n| the output will use the `\"fooBar\"` key (unless `useapinames=False` is passed).\n|\n| Args:\n| indent: Indentation to use in the JSON output. If `None` is passed, the output will be compact. Defaults to `2`\n| useapinames: Whether to use the key that the API responded with or the property name. Defaults to `True`.\n| excludeunset: Whether to exclude fields that have not been explicitly set.\n| excludedefaults: Whether to exclude fields that have the default value.\n| excludenone: Whether to exclude fields that have a value of `None`.\n| warnings: Whether to show any warnings that occurred during serialization. This is only supported in Pydantic v2.\n|\n| ----------------------------------------------------------------------\n| Class methods defined here:\n|\n| construct(fieldsset: 'set[str] | None' = None, values: 'object') -> 'ModelT' from pydantic.internal.modelconstruction.ModelMetaclass\n| # Override the 'construct' method in a way that supports recursive parsing without validation.\n| # Based on https://github.com/samuelcolvin/pydantic/issues/1168#issuecomment-817742836.\n|\n| modelconstruct = construct(fieldsset: 'set[str] | None' = None, values: 'object') -> 'ModelT' from pydantic.internal.modelconstruction.ModelMetaclass\n| # Override the 'construct' method in a way that supports recursive parsing without validation.\n| # Based on https://github.com/samuelcolvin/pydantic/issues/1168#issuecomment-817742836.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| abstractmethods = frozenset()\n|\n| annotations = {'modelconfig': 'ClassVar[ConfigDict]'}\n|\n| classvars = set()\n|\n| privateattributes = {}\n|\n| pydanticcomplete = True\n|\n| pydanticcomputedfields = {}\n|\n| pydanticcoreschema = {'cls': , 'config...\n|\n| pydanticcustominit = False\n|\n| pydanticdecorators = DecoratorInfos(validators={}, fieldvalidato...\n|\n| pydanticextrainfo = None\n|\n| pydanticfields = {}\n|\n| pydanticgenericmetadata = {'args': (), 'origin': None, 'paramete...\n|\n| pydanticparentnamespace = None\n|\n| pydanticpostinit = None\n|\n| pydanticserializer = SchemaSerializer(serializer=PolymorphismTram...\n|\n| pydanticsetattrhandlers = {}\n|\n| pydanticvalidator = SchemaValidator(title=\"BaseModel\", validator=...\n|\n| modelconfig = {'deferbuild': True, 'extra': 'allow'}\n|\n| ----------------------------------------------------------------------\n| Methods inherited from pydantic.main.BaseModel:\n|\n| copy(self) -> 'Self'\n| Returns a shallow copy of the model.\n|\n| deepcopy(self, memo: 'dict[int, Any] | None' = None) -> 'Self'\n| Returns a deep copy of the model.\n|\n| delattr(self, item: 'str') -> 'Any'\n| Implement delattr(self, name).\n|\n| eq(self, other: 'Any') -> 'bool'\n| Return self==value.\n|\n| getattr(self, item: 'str') -> 'Any'\n|\n| getstate(self) -> 'dict[Any, Any]'\n|\n| init(self, /, data: 'Any') -> 'None'\n| Create a new model by parsing and validating input data from keyword arguments.\n|\n| Raises [`ValidationError`][pydanticcore.ValidationError] if the input data cannot be\n| validated to form a valid model.\n|\n| `self` is explicitly positional-only to allow `self` as a field name.\n|\n| iter(self) -> 'TupleGenerator'\n| So `dict(model)` works.\n|\n| pretty(self, fmt: 'Callable[[Any], Any]', kwargs: 'Any') -> 'Generator[Any]'\n| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.\n|\n| replace(self, changes: 'Any') -> 'Self'\n| # Because we make use of `@dataclasstransform()`, `replace` is already synthesized by\n| # type checkers, so we define the implementation in this `if not TYPECHECKING:` block:\n|\n| repr(self) -> 'str'\n| Return repr(self).\n|\n| reprargs(self) -> 'repr.ReprArgs'\n|\n| reprname(self) -> 'str'\n| Name of the instance's class, used in repr.\n|\n| reprrecursion(self, object: 'Any') -> 'str'\n| Returns the string representation of a recursive object.\n|\n| reprstr(self, joinstr: 'str') -> 'str'\n|\n| richrepr(self) -> 'RichReprResult'\n| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.\n|\n| setattr(self, name: 'str', value: 'Any') -> 'None'\n| Implement setattr(self, name, value).\n|\n| setstate(self, state: 'dict[Any, Any]') -> 'None'\n|\n| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'\n| Returns a copy of the model.\n|\n| !!! warning \"Deprecated\"\n| This method is now deprecated; use `modelcopy` instead.\n|\n| If you need `include` or `exclude`, use:\n|\n| ```python {test=\"skip\" lint=\"skip\"}\n| data = self.modeldump(include=include, exclude=exclude, roundtrip=True)\n| data = {data, (update or {})}\n| copied = self.modelvalidate(data)\n| ```\n|\n| Args:\n| include: Optional set or mapping specifying which fields to include in the copied model.\n| exclude: Optional set or mapping specifying which fields to exclude in the copied model.\n| update: Optional dictionary of field-value pairs to override field values in the copied model.\n| deep: If True, the values of fields that are Pydantic models will be deep-copied.\n|\n| Returns:\n| A copy of the model with included, excluded and updated fields as specified.\n|\n| dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, byalias: 'bool' = False, excludeunset: 'bool' = False, excludedefaults: 'bool' = False, excludenone: 'bool' = False) -> 'Dict[str, Any]'\n|\n| json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, byalias: 'bool' = False, excludeunset: 'bool' = False, excludedefaults: 'bool' = False, excludenone: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, modelsasdict: 'bool' = PydanticUndefined, dumpskwargs: 'Any') -> 'str'\n|\n| modelcopy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'\n| !!! abstract \"Usage Documentation\"\n| [`modelcopy`](../concepts/models.md#model-copy)\n|\n| Returns a copy of the model.\n|\n| !!! note\n| The underlying instance's [`dict`][object.dict] attribute is copied. This\n| might have unexpected side effects if you store anything in it, on top of the model\n| fields (e.g. the value of [cached properties][functools.cachedproperty]).\n|\n| Args:\n| update: Values to change/add in the new model. Note: the data is not validated\n| before creating the new model. You should trust this data.\n| deep: Set to `True` to make a deep copy of the model.\n|\n| Returns:\n| New model instance.\n|\n| modeldump(self, *, mode: \"Literal['json', 'python'] | str\" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, byalias: 'bool | None' = None, excludeunset: 'bool' = False, excludedefaults: 'bool' = False, excludenone: 'bool' = False, excludecomputedfields: 'bool' = False, roundtrip: 'bool' = False, warnings: \"bool | Literal['none', 'warn', 'error']\" = True, fallback: 'Callable[[Any], Any] | None' = None, serializeasany: 'bool' = False, polymorphicserialization: 'bool | None' = None) -> 'dict[str, Any]'\n| !!! abstract \"Usage Documentation\"\n| [`modeldump`](../concepts/serialization.md#python-mode)\n|\n| Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.\n|\n| Args:\n| mode: The mode in which `topython` should run.\n| If mode is 'json', the output will only contain JSON serializable types.\n| If mode is 'python', the output may contain non-JSON-serializable Python objects.\n| include: A set of fields to include in the output.\n| exclude: A set of fields to exclude from the output.\n| context: Additional context to pass to the serializer.\n| byalias: Whether to use the field's alias in the dictionary key if defined.\n| excludeunset: Whether to exclude fields that have not been explicitly set.\n| excludedefaults: Whether to exclude fields that are set to their default value.\n| excludenone: Whether to exclude fields that have a value of `None`.\n| excludecomputedfields: Whether to exclude computed fields.\n| While this can be useful for round-tripping, it is usually recommended to use the dedicated\n| `roundtrip` parameter instead.\n| roundtrip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].\n| warnings: How to handle serialization errors. False/\"none\" ignores them, True/\"warn\" logs errors,\n| \"error\" raises a [`PydanticSerializationError`][pydanticcore.PydanticSerializationError].\n| fallback: A function to call when an unknown value is encountered. If not provided,\n| a [`PydanticSerializationError`][pydanticcore.PydanticSerializationError] error is raised.\n| serializeasany: Whether to serialize fields with duck-typing serialization behavior.\n| polymorphicserialization: Whether to use model and dataclass polymorphic serialization for this call.\n|\n| Returns:\n| A dictionary representation of the model.\n|\n| modeldumpjson(self, *, indent: 'int | None' = None, ensureascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, byalias: 'bool | None' = None, excludeunset: 'bool' = False, excludedefaults: 'bool' = False, excludenone: 'bool' = False, excludecomputedfields: 'bool' = False, roundtrip: 'bool' = False, warnings: \"bool | Literal['none', 'warn', 'error']\" = True, fallback: 'Callable[[Any], Any] | None' = None, serializeasany: 'bool' = False, polymorphicserialization: 'bool | None' = None) -> 'str'\n| !!! abstract \"Usage Documentation\"\n| [`modeldumpjson`](../concepts/serialization.md#json-mode)\n|\n| Generates a JSON representation of the model using Pydantic's `tojson` method.\n|\n| Args:\n| indent: Indentation to use in the JSON output. If None is passed, the output will be compact.\n| ensureascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.\n| If `False` (the default), these characters will be output as-is.\n| include: Field(s) to include in the JSON output.\n| exclude: Field(s) to exclude from the JSON output.\n| context: Additional context to pass to the serializer.\n| byalias: Whether to serialize using field aliases.\n| excludeunset: Whether to exclude fields that have not been explicitly set.\n| excludedefaults: Whether to exclude fields that are set to their default value.\n| excludenone: Whether to exclude fields that have a value of `None`.\n| excludecomputedfields: Whether to exclude computed fields.\n| While this can be useful for round-tripping, it is usually recommended to use the dedicated\n| `roundtrip` parameter instead.\n| roundtrip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].\n| warnings: How to handle serialization errors. False/\"none\" ignores them, True/\"warn\" logs errors,\n| \"error\" raises a [`PydanticSerializationError`][pydanticcore.PydanticSerializationError].\n| fallback: A function to call when an unknown value is encountered. If not provided,\n| a [`PydanticSerializationError`][pydanticcore.PydanticSerializationError] error is raised.\n| serializeasany: Whether to serialize fields with duck-typing serialization behavior.\n| polymorphicserialization: Whether to use model and dataclass polymorphic serialization for this call.\n|\n| Returns:\n| A JSON string representation of the model.\n|\n| modelpostinit(self, context: 'Any', /) -> 'None'\n| Override this method to perform additional initialization after `init` and `modelconstruct`.\n| This is useful if you want to do some validation that requires the entire model to be initialized.\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from pydantic.main.BaseModel:\n|\n| classgetitem(typevarvalues: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | forwardref.PydanticRecursiveRef' from pydantic.internal.modelconstruction.ModelMetaclass\n|\n| getpydanticcoreschema(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from pydantic.internal.modelconstruction.ModelMetaclass\n|\n| getpydanticjsonschema(coreschema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from pydantic.internal.modelconstruction.ModelMetaclass\n| Hook into generating the model's JSON schema.\n|\n| Args:\n| coreschema: A `pydantic-core` CoreSchema.\n| You can ignore this argument and call the handler with a new CoreSchema,\n| wrap this CoreSchema (`{'type': 'nullable', 'schema': currentschema}`),\n| or just call the handler with the original schema.\n| handler: Call into Pydantic's internal JSON schema generation.\n| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema\n| generation fails.\n| Since this gets called by `BaseModel.modeljsonschema` you can override the\n| `schemagenerator` argument to that function to change JSON schema generation globally\n| for a type.\n|\n| Returns:\n| A JSON schema, as a Python object.\n|\n| pydanticinitsubclass(kwargs: 'Any') -> 'None' from pydantic.internal.modelconstruction.ModelMetaclass\n| This is intended to behave just like `initsubclass`, but is called by `ModelMetaclass`\n| only after basic class initialization is complete. In particular, attributes like `modelfields` will\n| be present when this is called, but forward annotations are not guaranteed to be resolved yet,\n| meaning that creating an instance of the class may fail.\n|\n| This is necessary because `initsubclass` will always be called by `type.new`,\n| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that\n| `type.new` was called in such a manner that the class would already be sufficiently initialized.\n|\n| This will receive the same `kwargs` that would be passed to the standard `initsubclass`, namely,\n| any kwargs passed to the class definition that aren't used internally by Pydantic.\n|\n| Args:\n| kwargs: Any keyword arguments passed to the class definition that aren't used internally\n| by Pydantic.\n|\n| Note:\n| You may want to override [`pydanticoncomplete()`][pydantic.main.BaseModel.pydanticoncomplete]\n| instead, which is called once the class and its fields are fully initialized and ready for validation.\n|\n| pydanticoncomplete() -> 'None' from pydantic.internal.modelconstruction.ModelMetaclass\n| This is called once the class and its fields are fully initialized and ready to be used.\n|\n| This typically happens when the class is created (just before\n| [`pydanticinitsubclass()`][pydantic.main.BaseModel.pydanticinitsubclass] is called on the superclass),\n| except when forward annotations are used that could not immediately be resolved.\n| In that case, it will be called later, when the model is rebuilt automatically or explicitly using\n| [`modelrebuild()`][pydantic.main.BaseModel.modelrebuild].\n|\n| fromorm(obj: 'Any') -> 'Self' from pydantic.internal.modelconstruction.ModelMetaclass\n|\n| modeljsonschema(byalias: 'bool' = True, reftemplate: 'str' = '#/$defs/{model}', schemagenerator: 'type[GenerateJsonSchema]' = , mode: 'JsonSchemaMode' = 'validation', *, unionformat: \"Literal['anyof', 'primitivetypearray']\" = 'anyof') -> 'dict[str, Any]' from pydantic.internal.modelconstruction.ModelMetaclass\n| Generates a JSON schema for a model class.\n|\n| Args:\n| byalias: Whether to use attribute aliases or not.\n| reftemplate: The reference template.\n| unionformat: The format to use when combining schemas from unions together. Can be one of:\n|\n| - `'anyof'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)\n| keyword to combine schemas (the default).\n| - `'primitivetypearray'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)\n| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive\n| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to\n| `anyof`.\n| schemagenerator: To override the logic used to generate the JSON schema, as a subclass of\n| `GenerateJsonSchema` with your desired modifications\n| mode: The mode in which to generate the schema.\n|\n| Returns:\n| The JSON schema for the given model class.\n|\n| modelparametrizedname(params: 'tuple[type[Any], ...]') -> 'str' from pydantic.internal.modelconstruction.ModelMetaclass\n| Compute the class name for parametrizations of generic classes.\n|\n| This method can be overridden to achieve a custom naming scheme for generic BaseModels.\n|\n| Args:\n| params: Tuple of types of the class. Given a generic class\n| `Model` with 2 type variables and a concrete model `Model[str, int]`,\n| the value `(str, int)` would be passed to `params`.\n|\n| Returns:\n| String representing the new class where `params` are passed to `cls` as type variables.\n|\n| Raises:\n| TypeError: Raised when trying to generate concrete names for non-generic models.\n|\n| modelrebuild(*, force: 'bool' = False, raiseerrors: 'bool' = True, parentnamespacedepth: 'int' = 2, typesnamespace: 'MappingNamespace | None' = None) -> 'bool | None' from pydantic.internal.modelconstruction.ModelMetaclass\n| Try to rebuild the pydantic-core schema for the model.\n|\n| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during\n| the initial attempt to build the schema, and automatic rebuilding fails.\n|\n| Args:\n| force: Whether to force the rebuilding of the model schema, defaults to `False`.\n| raiseerrors: Whether to raise errors, defaults to `True`.\n| parentnamespacedepth: The depth level of the parent namespace, defaults to 2.\n| typesnamespace: The types namespace, defaults to `None`.\n|\n| Returns:\n| Returns `None` if the schema is already \"complete\" and rebuilding was not required.\n| If rebuilding was required, returns `True` if rebuilding was successful, otherwise `False`.\n|\n| modelvalidate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, fromattributes: 'bool | None' = None, context: 'Any | None' = None, byalias: 'bool | None' = None, byname: 'bool | None' = None) -> 'Self' from pydantic.internal.modelconstruction.ModelMetaclass\n| Validate a pydantic model instance.\n|\n| Args:\n| obj: The object to validate.\n| strict: Whether to enforce types strictly.\n| extra: Whether to ignore, allow, or forbid extra data during model validation.\n| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.\n| fromattributes: Whether to extract data from object attributes.\n| context: Additional context to pass to the validator.\n| byalias: Whether to use the field's alias when validating against the provided input data.\n| byname: Whether to use the field's name when validating against the provided input data.\n|\n| Raises:\n| ValidationError: If the object could not be validated.\n|\n| Returns:\n| The validated model instance.\n|\n| modelvalidatejson(jsondata: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, byalias: 'bool | None' = None, byname: 'bool | None' = None) -> 'Self' from pydantic.internal.modelconstruction.ModelMetaclass\n| !!! abstract \"Usage Documentation\"\n| [JSON Parsing](../concepts/json.md#json-parsing)\n|\n| Validate the given JSON data against the Pydantic model.\n|\n| Args:\n| jsondata: The JSON data to validate.\n| strict: Whether to enforce types strictly.\n| extra: Whether to ignore, allow, or forbid extra data during model validation.\n| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.\n| context: Extra variables to pass to the validator.\n| byalias: Whether to use the field's alias when validating against the provided input data.\n| byname: Whether to use the field's name when validating against the provided input data.\n|\n| Returns:\n| The validated Pydantic model.\n|\n| Raises:\n| ValidationError: If `jsondata` is not a JSON string or the object could not be validated.\n|\n| modelvalidatestrings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, byalias: 'bool | None' = None, byname: 'bool | None' = None) -> 'Self' from pydantic.internal.modelconstruction.ModelMetaclass\n| Validate the given object with string data against the Pydantic model.\n|\n| Args:\n| obj: The object containing string data to validate.\n| strict: Whether to enforce types strictly.\n| extra: Whether to ignore, allow, or forbid extra data during model validation.\n| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.\n| context: Extra variables to pass to the validator.\n| byalias: Whether to use the field's alias when validating against the provided input data.\n| byname: Whether to use the field's name when validating against the provided input data.\n|\n| Returns:\n| The validated Pydantic model.\n|\n| parsefile(path: 'str | Path', *, contenttype: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allowpickle: 'bool' = False) -> 'Self' from pydantic.internal.modelconstruction.ModelMetaclass\n|\n| parseobj(obj: 'Any') -> 'Self' from pydantic.internal.modelconstruction.ModelMetaclass\n|\n| parseraw(b: 'str | bytes', *, contenttype: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allowpickle: 'bool' = False) -> 'Self' from pydantic.internal.modelconstruction.ModelMetaclass\n|\n| schema(byalias: 'bool' = True, reftemplate: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from pydantic.internal.modelconstruction.ModelMetaclass\n|\n| schemajson(*, byalias: 'bool' = True, reftemplate: 'str' = '#/$defs/{model}', dumpskwargs: 'Any') -> 'str' from pydantic.internal.modelconstruction.ModelMetaclass\n|\n| updateforwardrefs(localns: 'Any') -> 'None' from pydantic.internal.modelconstruction.ModelMetaclass\n|\n| validate(value: 'Any') -> 'Self' from pydantic.internal.modelconstruction.ModelMetaclass\n|\n| ----------------------------------------------------------------------\n| Readonly properties inherited from pydantic.main.BaseModel:\n|\n| fieldsset\n|\n| modelextra\n| Get extra fields set during validation.\n|\n| Returns:\n| A dictionary of extra fields, or `None` if `config.extra` is not set to `\"allow\"`.\n|\n| modelfieldsset\n| Returns the set of fields that have been explicitly set on this model instance.\n|\n| Returns:\n| A set of strings representing the fields that have been set,\n| i.e. that were not filled from defaults.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from pydantic.main.BaseModel:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| pydanticextra\n|\n| pydanticfieldsset\n|\n| pydanticprivate\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from pydantic.main.BaseModel:\n|\n| hash = None\n|\n| pydanticrootmodel = False\n|\n| modelcomputedfields = {}\n|\n| modelfields = {}\n" }, { "name": "class BedrockOpenAI", "content": "| BedrockOpenAI(*, apikey: 'str | None' = None, bedrocktokenprovider: 'BedrockTokenProvider | None' = None, awsregion: 'str | None' = None, awsprofile: 'str | None' = None, awsaccesskeyid: 'str | None' = None, awssecretaccesskey: 'str | None' = None, awssessiontoken: 'str | None' = None, awscredentialsprovider: 'AwsCredentialsProvider | None' = None, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, baseurl: 'str | httpx.URL | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, maxretries: 'int' = 2, defaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, httpclient: 'httpx.Client | None' = None, strictresponsevalidation: 'bool' = False, enforcecredentials: 'bool' = True, provider: 'Provider | None' = None, state: 'LegacyBedrockState | None' = None, regionwasexplicit: 'bool | None' = None) -> 'None'\n|\n| Compatibility client for Amazon Bedrock's OpenAI-compatible endpoint.\n|\n| Method resolution order:\n| BedrockOpenAI\n| OpenAI\n| openai.baseclient.SyncAPIClient\n| openai.baseclient.BaseClient\n| typing.Generic\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, *, apikey: 'str | None' = None, bedrocktokenprovider: 'BedrockTokenProvider | None' = None, awsregion: 'str | None' = None, awsprofile: 'str | None' = None, awsaccesskeyid: 'str | None' = None, awssecretaccesskey: 'str | None' = None, awssessiontoken: 'str | None' = None, awscredentialsprovider: 'AwsCredentialsProvider | None' = None, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, baseurl: 'str | httpx.URL | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, maxretries: 'int' = 2, defaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, httpclient: 'httpx.Client | None' = None, strictresponsevalidation: 'bool' = False, enforcecredentials: 'bool' = True, provider: 'Provider | None' = None, state: 'LegacyBedrockState | None' = None, regionwasexplicit: 'bool | None' = None) -> 'None'\n| Construct a new synchronous OpenAI client instance.\n|\n| This automatically infers the following arguments from their corresponding environment variables if they are not provided:\n| - `apikey` from `OPENAIAPIKEY`\n| - `adminapikey` from `OPENAIADMINKEY`\n| - `organization` from `OPENAIORGID`\n| - `project` from `OPENAIPROJECTID`\n| - `webhooksecret` from `OPENAIWEBHOOKSECRET`\n|\n| When `provider` is supplied, authentication and the base URL are configured by that provider instead.\n|\n| copy(self, *, apikey: 'str | BedrockTokenProvider | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, provider: 'Provider | None | NotGiven' = NOTGIVEN, bedrocktokenprovider: 'BedrockTokenProvider | None' = None, awsregion: 'str | None' = None, awsprofile: 'str | None' = None, awsaccesskeyid: 'str | None' = None, awssecretaccesskey: 'str | None' = None, awssessiontoken: 'str | None' = None, awscredentialsprovider: 'AwsCredentialsProvider | None' = None, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, baseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, httpclient: 'httpx.Client | None' = None, maxretries: 'int | NotGiven' = NOTGIVEN, defaultheaders: 'Mapping[str, str] | None' = None, setdefaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, setdefaultquery: 'Mapping[str, object] | None' = None, enforcecredentials: 'bool | None' = None, extrakwargs: 'Mapping[str, Any]' = {}) -> 'Self'\n| Create a new client instance re-using the same options given to the current client with optional overriding.\n|\n| withoptions = copy(self, *, apikey: 'str | BedrockTokenProvider | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, provider: 'Provider | None | NotGiven' = NOTGIVEN, bedrocktokenprovider: 'BedrockTokenProvider | None' = None, awsregion: 'str | None' = None, awsprofile: 'str | None' = None, awsaccesskeyid: 'str | None' = None, awssecretaccesskey: 'str | None' = None, awssessiontoken: 'str | None' = None, awscredentialsprovider: 'AwsCredentialsProvider | None' = None, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, baseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, httpclient: 'httpx.Client | None' = None, maxretries: 'int | NotGiven' = NOTGIVEN, defaultheaders: 'Mapping[str, str] | None' = None, setdefaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, setdefaultquery: 'Mapping[str, object] | None' = None, enforcecredentials: 'bool | None' = None, extrakwargs: 'Mapping[str, Any]' = {}) -> 'Self'\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {'bedrockprovider': 'Provider', 'bedrockruntime...\n|\n| parameters = ()\n|\n| ----------------------------------------------------------------------\n| Methods inherited from OpenAI:\n|\n| admin = \n| audio = \n| batches = \n| Create large batches of API requests to run asynchronously.\n|\n| beta = \n| chat = \n| completions = \n| Given a prompt, the model will return one or more predicted completions, and can also return the probabilities of alternative tokens at each position.\n|\n| containers = \n| conversations = \n| Manage conversations and conversation items.\n|\n| embeddings = \n| Get a vector representation of a given input that can be easily consumed by machine learning models and algorithms.\n|\n| evals = \n| Manage and run evals in the OpenAI platform.\n|\n| files = \n| Files are used to upload documents that can be used with features like Assistants and Fine-tuning.\n|\n| finetuning = \n| images = \n| Given a prompt and/or an input image, the model will generate a new image.\n|\n| models = \n| List and describe the various models available in the API.\n|\n| moderations = \n| Given text and/or image inputs, classifies if those inputs are potentially harmful.\n|\n| realtime = \n| responses = \n| skills = \n| uploads = \n| Use Uploads to upload large files in multiple parts.\n|\n| vectorstores = \n| videos = \n| webhooks = \n| withrawresponse = \n| withstreamingresponse = \n| ----------------------------------------------------------------------\n| Readonly properties inherited from OpenAI:\n|\n| authheaders\n|\n| defaultheaders\n|\n| qs\n|\n| ----------------------------------------------------------------------\n| Methods inherited from openai.baseclient.SyncAPIClient:\n|\n| enter(self: 'T') -> 'T'\n|\n| exit(self, exctype: 'type[BaseException] | None', exc: 'BaseException | None', exctb: 'TracebackType | None') -> 'None'\n|\n| close(self) -> 'None'\n| Close the underlying HTTPX client.\n|\n| The client will *not* be usable after this.\n|\n| delete(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'BinaryTypes | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| get(self, path: 'str', *, castto: 'Type[ResponseT]', options: 'RequestOptions' = {}, stream: 'bool' = False, streamcls: 'type[StreamT] | None' = None) -> 'ResponseT | StreamT'\n|\n| getapilist(self, path: 'str', *, model: 'Type[object]', page: 'Type[SyncPageT]', body: 'Body | None' = None, options: 'RequestOptions' = {}, method: 'str' = 'get') -> 'SyncPageT'\n|\n| isclosed(self) -> 'bool'\n|\n| patch(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'BinaryTypes | None' = None, files: 'RequestFiles | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| post(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'BinaryTypes | None' = None, options: 'RequestOptions' = {}, files: 'RequestFiles | None' = None, stream: 'bool' = False, streamcls: 'type[StreamT] | None' = None) -> 'ResponseT | StreamT'\n|\n| put(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'BinaryTypes | None' = None, files: 'RequestFiles | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| request(self, castto: 'Type[ResponseT]', options: 'FinalRequestOptions', *, stream: 'bool' = False, streamcls: 'type[StreamT] | None' = None) -> 'ResponseT | StreamT'\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from openai.baseclient.SyncAPIClient:\n|\n| origbases = (openai.baseclient.BaseClient[httpx.Client, openai....\n|\n| ----------------------------------------------------------------------\n| Methods inherited from openai.baseclient.BaseClient:\n|\n| platformheaders(self) -> 'Dict[str, str]'\n|\n| ----------------------------------------------------------------------\n| Readonly properties inherited from openai.baseclient.BaseClient:\n|\n| customauth\n|\n| defaultquery\n|\n| useragent\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from openai.baseclient.BaseClient:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| baseurl\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from typing.Generic:\n|\n| classgetitem(params) from builtins.type\n|\n| initsubclass(*args, kwargs) from builtins.type\n| This method is called when a class is subclassed.\n|\n| The default implementation does nothing. It may be\n| overridden to extend subclasses.\n\nClient = class OpenAI(openai.baseclient.SyncAPIClient)\n| Client(*, apikey: 'str | Callable[[], str] | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, provider: 'Provider | None' = None, baseurl: 'str | httpx.URL | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, maxretries: 'int' = 2, defaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, httpclient: 'httpx.Client | None' = None, strictresponsevalidation: 'bool' = False, enforcecredentials: 'bool' = True) -> 'None'\n|\n| Method resolution order:\n| OpenAI\n| openai.baseclient.SyncAPIClient\n| openai.baseclient.BaseClient\n| typing.Generic\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, *, apikey: 'str | Callable[[], str] | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, provider: 'Provider | None' = None, baseurl: 'str | httpx.URL | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, maxretries: 'int' = 2, defaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, httpclient: 'httpx.Client | None' = None, strictresponsevalidation: 'bool' = False, enforcecredentials: 'bool' = True) -> 'None'\n| Construct a new synchronous OpenAI client instance.\n|\n| This automatically infers the following arguments from their corresponding environment variables if they are not provided:\n| - `apikey` from `OPENAIAPIKEY`\n| - `adminapikey` from `OPENAIADMINKEY`\n| - `organization` from `OPENAIORGID`\n| - `project` from `OPENAIPROJECTID`\n| - `webhooksecret` from `OPENAIWEBHOOKSECRET`\n|\n| When `provider` is supplied, authentication and the base URL are configured by that provider instead.\n|\n| admin = \n| audio = \n| batches = \n| Create large batches of API requests to run asynchronously.\n|\n| beta = \n| chat = \n| completions = \n| Given a prompt, the model will return one or more predicted completions, and can also return the probabilities of alternative tokens at each position.\n|\n| containers = \n| conversations = \n| Manage conversations and conversation items.\n|\n| copy(self, *, apikey: 'str | Callable[[], str] | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, provider: 'Provider | None | NotGiven' = NOTGIVEN, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, baseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, httpclient: 'httpx.Client | None' = None, maxretries: 'int | NotGiven' = NOTGIVEN, defaultheaders: 'Mapping[str, str] | None' = None, setdefaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, setdefaultquery: 'Mapping[str, object] | None' = None, enforcecredentials: 'bool | None' = None, extrakwargs: 'Mapping[str, Any]' = {}) -> 'Self'\n| Create a new client instance re-using the same options given to the current client with optional overriding.\n|\n| embeddings = \n| Get a vector representation of a given input that can be easily consumed by machine learning models and algorithms.\n|\n| evals = \n| Manage and run evals in the OpenAI platform.\n|\n| files = \n| Files are used to upload documents that can be used with features like Assistants and Fine-tuning.\n|\n| finetuning = \n| images = \n| Given a prompt and/or an input image, the model will generate a new image.\n|\n| models = \n| List and describe the various models available in the API.\n|\n| moderations = \n| Given text and/or image inputs, classifies if those inputs are potentially harmful.\n|\n| realtime = \n| responses = \n| skills = \n| uploads = \n| Use Uploads to upload large files in multiple parts.\n|\n| vectorstores = \n| videos = \n| webhooks = \n| withoptions = copy(self, *, apikey: 'str | Callable[[], str] | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, provider: 'Provider | None | NotGiven' = NOTGIVEN, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, baseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, httpclient: 'httpx.Client | None' = None, maxretries: 'int | NotGiven' = NOTGIVEN, defaultheaders: 'Mapping[str, str] | None' = None, setdefaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, setdefaultquery: 'Mapping[str, object] | None' = None, enforcecredentials: 'bool | None' = None, extrakwargs: 'Mapping[str, Any]' = {}) -> 'Self'\n|\n| withrawresponse = \n| withstreamingresponse = \n| ----------------------------------------------------------------------\n| Readonly properties defined here:\n|\n| authheaders\n|\n| defaultheaders\n|\n| qs\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {'provider': 'Provider | None', 'providerruntime...\n|\n| parameters = ()\n|\n| ----------------------------------------------------------------------\n| Methods inherited from openai.baseclient.SyncAPIClient:\n|\n| enter(self: 'T') -> 'T'\n|\n| exit(self, exctype: 'type[BaseException] | None', exc: 'BaseException | None', exctb: 'TracebackType | None') -> 'None'\n|\n| close(self) -> 'None'\n| Close the underlying HTTPX client.\n|\n| The client will *not* be usable after this.\n|\n| delete(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'BinaryTypes | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| get(self, path: 'str', *, castto: 'Type[ResponseT]', options: 'RequestOptions' = {}, stream: 'bool' = False, streamcls: 'type[StreamT] | None' = None) -> 'ResponseT | StreamT'\n|\n| getapilist(self, path: 'str', *, model: 'Type[object]', page: 'Type[SyncPageT]', body: 'Body | None' = None, options: 'RequestOptions' = {}, method: 'str' = 'get') -> 'SyncPageT'\n|\n| isclosed(self) -> 'bool'\n|\n| patch(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'BinaryTypes | None' = None, files: 'RequestFiles | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| post(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'BinaryTypes | None' = None, options: 'RequestOptions' = {}, files: 'RequestFiles | None' = None, stream: 'bool' = False, streamcls: 'type[StreamT] | None' = None) -> 'ResponseT | StreamT'\n|\n| put(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'BinaryTypes | None' = None, files: 'RequestFiles | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| request(self, castto: 'Type[ResponseT]', options: 'FinalRequestOptions', *, stream: 'bool' = False, streamcls: 'type[StreamT] | None' = None) -> 'ResponseT | StreamT'\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from openai.baseclient.SyncAPIClient:\n|\n| origbases = (openai.baseclient.BaseClient[httpx.Client, openai....\n|\n| ----------------------------------------------------------------------\n| Methods inherited from openai.baseclient.BaseClient:\n|\n| platformheaders(self) -> 'Dict[str, str]'\n|\n| ----------------------------------------------------------------------\n| Readonly properties inherited from openai.baseclient.BaseClient:\n|\n| customauth\n|\n| defaultquery\n|\n| useragent\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from openai.baseclient.BaseClient:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| baseurl\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from typing.Generic:\n|\n| classgetitem(params) from builtins.type\n|\n| initsubclass(*args, kwargs) from builtins.type\n| This method is called when a class is subclassed.\n|\n| The default implementation does nothing. It may be\n| overridden to extend subclasses.\n" }, { "name": "class ConflictError", "content": "| ConflictError(message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n|\n| Method resolution order:\n| ConflictError\n| APIStatusError\n| APIError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data and other attributes defined here:\n|\n| annotations = {'statuscode': 'Literal[409]'}\n|\n| statuscode = 409\n|\n| ----------------------------------------------------------------------\n| Methods inherited from APIStatusError:\n|\n| init(self, message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from APIError:\n|\n| code = None\n|\n| param = None\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class ContentFilterFinishReasonError", "content": "| ContentFilterFinishReasonError() -> 'None'\n|\n| Method resolution order:\n| ContentFilterFinishReasonError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self) -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {}\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n\nDefaultAioHttpClient = class DefaultAioHttpClient(httpx.AsyncClient)\n| DefaultAioHttpClient(kwargs: 'Any') -> 'None'\n|\n| Method resolution order:\n| DefaultAioHttpClient\n| httpx.AsyncClient\n| httpx.client.BaseClient\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, kwargs: 'Any') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from httpx.AsyncClient:\n|\n| async aenter(self: 'U') -> 'U'\n|\n| async aexit(self, exctype: 'type[BaseException] | None' = None, excvalue: 'BaseException | None' = None, traceback: 'TracebackType | None' = None) -> 'None'\n|\n| async aclose(self) -> 'None'\n| Close transport and proxies.\n|\n| async delete(self, url: 'URL | str', *, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `DELETE` request.\n|\n| Parameters: See `httpx.request`.\n|\n| async get(self, url: 'URL | str', *, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault | None' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `GET` request.\n|\n| Parameters: See `httpx.request`.\n|\n| async head(self, url: 'URL | str', *, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `HEAD` request.\n|\n| Parameters: See `httpx.request`.\n|\n| async options(self, url: 'URL | str', *, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send an `OPTIONS` request.\n|\n| Parameters: See `httpx.request`.\n|\n| async patch(self, url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `PATCH` request.\n|\n| Parameters: See `httpx.request`.\n|\n| async post(self, url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `POST` request.\n|\n| Parameters: See `httpx.request`.\n|\n| async put(self, url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `PUT` request.\n|\n| Parameters: See `httpx.request`.\n|\n| async request(self, method: 'str', url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault | None' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Build and send a request.\n|\n| Equivalent to:\n|\n| ```python\n| request = client.buildrequest(...)\n| response = await client.send(request, ...)\n| ```\n|\n| See `AsyncClient.buildrequest()`, `AsyncClient.send()`\n| and [Merging of configuration][0] for how the various parameters\n| are merged with client-level configuration.\n|\n| [0]: /advanced/clients/#merging-of-configuration\n|\n| async send(self, request: 'Request', *, stream: 'bool' = False, auth: 'AuthTypes | UseClientDefault | None' = , followredirects: 'bool | UseClientDefault' = ) -> 'Response'\n| Send a request.\n|\n| The request is sent as-is, unmodified.\n|\n| Typically you'll want to build one with `AsyncClient.buildrequest()`\n| so that any client-level configuration is merged into the request,\n| but passing an explicit `httpx.Request()` is supported as well.\n|\n| See also: [Request instances][0]\n|\n| [0]: /advanced/clients/#request-instances\n|\n| stream(self, method: 'str', url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault | None' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'typing.AsyncIterator[Response]'\n| Alternative to `httpx.request()` that streams the response body\n| instead of loading it into memory at once.\n|\n| Parameters: See `httpx.request`.\n|\n| See also: [Streaming Responses][0]\n|\n| [0]: /quickstart#streaming-responses\n|\n| ----------------------------------------------------------------------\n| Methods inherited from httpx.client.BaseClient:\n|\n| buildrequest(self, method: 'str', url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Request'\n| Build and return a request instance.\n|\n| * The `params`, `headers` and `cookies` arguments\n| are merged with any values set on the client.\n| * The `url` argument is merged with any `baseurl` set on the client.\n|\n| See also: [Request instances][0]\n|\n| [0]: /advanced/clients/#request-instances\n|\n| ----------------------------------------------------------------------\n| Readonly properties inherited from httpx.client.BaseClient:\n|\n| isclosed\n| Check if the client being closed\n|\n| trustenv\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from httpx.client.BaseClient:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| auth\n| Authentication class used when none is passed at the request-level.\n|\n| See also [Authentication][0].\n|\n| [0]: /quickstart/#authentication\n|\n| baseurl\n| Base URL to use when sending requests with relative URLs.\n|\n| cookies\n| Cookie values to include when sending requests.\n|\n| eventhooks\n|\n| headers\n| HTTP headers to include when sending requests.\n|\n| params\n| Query parameters to include in the URL when sending requests.\n|\n| timeout\n\nDefaultAsyncHttpxClient = class DefaultAsyncHttpxClient(httpx.AsyncClient)\n| DefaultAsyncHttpxClient(kwargs: 'Any') -> 'None'\n|\n| Method resolution order:\n| DefaultAsyncHttpxClient\n| httpx.AsyncClient\n| httpx.client.BaseClient\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, kwargs: 'Any') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from httpx.AsyncClient:\n|\n| async aenter(self: 'U') -> 'U'\n|\n| async aexit(self, exctype: 'type[BaseException] | None' = None, excvalue: 'BaseException | None' = None, traceback: 'TracebackType | None' = None) -> 'None'\n|\n| async aclose(self) -> 'None'\n| Close transport and proxies.\n|\n| async delete(self, url: 'URL | str', *, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `DELETE` request.\n|\n| Parameters: See `httpx.request`.\n|\n| async get(self, url: 'URL | str', *, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault | None' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `GET` request.\n|\n| Parameters: See `httpx.request`.\n|\n| async head(self, url: 'URL | str', *, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `HEAD` request.\n|\n| Parameters: See `httpx.request`.\n|\n| async options(self, url: 'URL | str', *, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send an `OPTIONS` request.\n|\n| Parameters: See `httpx.request`.\n|\n| async patch(self, url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `PATCH` request.\n|\n| Parameters: See `httpx.request`.\n|\n| async post(self, url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `POST` request.\n|\n| Parameters: See `httpx.request`.\n|\n| async put(self, url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `PUT` request.\n|\n| Parameters: See `httpx.request`.\n|\n| async request(self, method: 'str', url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault | None' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Build and send a request.\n|\n| Equivalent to:\n|\n| ```python\n| request = client.buildrequest(...)\n| response = await client.send(request, ...)\n| ```\n|\n| See `AsyncClient.buildrequest()`, `AsyncClient.send()`\n| and [Merging of configuration][0] for how the various parameters\n| are merged with client-level configuration.\n|\n| [0]: /advanced/clients/#merging-of-configuration\n|\n| async send(self, request: 'Request', *, stream: 'bool' = False, auth: 'AuthTypes | UseClientDefault | None' = , followredirects: 'bool | UseClientDefault' = ) -> 'Response'\n| Send a request.\n|\n| The request is sent as-is, unmodified.\n|\n| Typically you'll want to build one with `AsyncClient.buildrequest()`\n| so that any client-level configuration is merged into the request,\n| but passing an explicit `httpx.Request()` is supported as well.\n|\n| See also: [Request instances][0]\n|\n| [0]: /advanced/clients/#request-instances\n|\n| stream(self, method: 'str', url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault | None' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'typing.AsyncIterator[Response]'\n| Alternative to `httpx.request()` that streams the response body\n| instead of loading it into memory at once.\n|\n| Parameters: See `httpx.request`.\n|\n| See also: [Streaming Responses][0]\n|\n| [0]: /quickstart#streaming-responses\n|\n| ----------------------------------------------------------------------\n| Methods inherited from httpx.client.BaseClient:\n|\n| buildrequest(self, method: 'str', url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Request'\n| Build and return a request instance.\n|\n| * The `params`, `headers` and `cookies` arguments\n| are merged with any values set on the client.\n| * The `url` argument is merged with any `baseurl` set on the client.\n|\n| See also: [Request instances][0]\n|\n| [0]: /advanced/clients/#request-instances\n|\n| ----------------------------------------------------------------------\n| Readonly properties inherited from httpx.client.BaseClient:\n|\n| isclosed\n| Check if the client being closed\n|\n| trustenv\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from httpx.client.BaseClient:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| auth\n| Authentication class used when none is passed at the request-level.\n|\n| See also [Authentication][0].\n|\n| [0]: /quickstart/#authentication\n|\n| baseurl\n| Base URL to use when sending requests with relative URLs.\n|\n| cookies\n| Cookie values to include when sending requests.\n|\n| eventhooks\n|\n| headers\n| HTTP headers to include when sending requests.\n|\n| params\n| Query parameters to include in the URL when sending requests.\n|\n| timeout\n\nDefaultHttpxClient = class DefaultHttpxClient(httpx.Client)\n| DefaultHttpxClient(kwargs: 'Any') -> 'None'\n|\n| Method resolution order:\n| DefaultHttpxClient\n| httpx.Client\n| httpx.client.BaseClient\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, kwargs: 'Any') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from httpx.Client:\n|\n| enter(self: 'T') -> 'T'\n|\n| exit(self, exctype: 'type[BaseException] | None' = None, excvalue: 'BaseException | None' = None, traceback: 'TracebackType | None' = None) -> 'None'\n|\n| close(self) -> 'None'\n| Close transport and proxies.\n|\n| delete(self, url: 'URL | str', *, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `DELETE` request.\n|\n| Parameters: See `httpx.request`.\n|\n| get(self, url: 'URL | str', *, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault | None' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `GET` request.\n|\n| Parameters: See `httpx.request`.\n|\n| head(self, url: 'URL | str', *, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `HEAD` request.\n|\n| Parameters: See `httpx.request`.\n|\n| options(self, url: 'URL | str', *, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send an `OPTIONS` request.\n|\n| Parameters: See `httpx.request`.\n|\n| patch(self, url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `PATCH` request.\n|\n| Parameters: See `httpx.request`.\n|\n| post(self, url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `POST` request.\n|\n| Parameters: See `httpx.request`.\n|\n| put(self, url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Send a `PUT` request.\n|\n| Parameters: See `httpx.request`.\n|\n| request(self, method: 'str', url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault | None' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Response'\n| Build and send a request.\n|\n| Equivalent to:\n|\n| ```python\n| request = client.buildrequest(...)\n| response = client.send(request, ...)\n| ```\n|\n| See `Client.buildrequest()`, `Client.send()` and\n| [Merging of configuration][0] for how the various parameters\n| are merged with client-level configuration.\n|\n| [0]: /advanced/clients/#merging-of-configuration\n|\n| send(self, request: 'Request', *, stream: 'bool' = False, auth: 'AuthTypes | UseClientDefault | None' = , followredirects: 'bool | UseClientDefault' = ) -> 'Response'\n| Send a request.\n|\n| The request is sent as-is, unmodified.\n|\n| Typically you'll want to build one with `Client.buildrequest()`\n| so that any client-level configuration is merged into the request,\n| but passing an explicit `httpx.Request()` is supported as well.\n|\n| See also: [Request instances][0]\n|\n| [0]: /advanced/clients/#request-instances\n|\n| stream(self, method: 'str', url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, auth: 'AuthTypes | UseClientDefault | None' = , followredirects: 'bool | UseClientDefault' = , timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'typing.Iterator[Response]'\n| Alternative to `httpx.request()` that streams the response body\n| instead of loading it into memory at once.\n|\n| Parameters: See `httpx.request`.\n|\n| See also: [Streaming Responses][0]\n|\n| [0]: /quickstart#streaming-responses\n|\n| ----------------------------------------------------------------------\n| Methods inherited from httpx.client.BaseClient:\n|\n| buildrequest(self, method: 'str', url: 'URL | str', *, content: 'RequestContent | None' = None, data: 'RequestData | None' = None, files: 'RequestFiles | None' = None, json: 'typing.Any | None' = None, params: 'QueryParamTypes | None' = None, headers: 'HeaderTypes | None' = None, cookies: 'CookieTypes | None' = None, timeout: 'TimeoutTypes | UseClientDefault' = , extensions: 'RequestExtensions | None' = None) -> 'Request'\n| Build and return a request instance.\n|\n| * The `params`, `headers` and `cookies` arguments\n| are merged with any values set on the client.\n| * The `url` argument is merged with any `baseurl` set on the client.\n|\n| See also: [Request instances][0]\n|\n| [0]: /advanced/clients/#request-instances\n|\n| ----------------------------------------------------------------------\n| Readonly properties inherited from httpx.client.BaseClient:\n|\n| isclosed\n| Check if the client being closed\n|\n| trustenv\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from httpx.client.BaseClient:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| auth\n| Authentication class used when none is passed at the request-level.\n|\n| See also [Authentication][0].\n|\n| [0]: /quickstart/#authentication\n|\n| baseurl\n| Base URL to use when sending requests with relative URLs.\n|\n| cookies\n| Cookie values to include when sending requests.\n|\n| eventhooks\n|\n| headers\n| HTTP headers to include when sending requests.\n|\n| params\n| Query parameters to include in the URL when sending requests.\n|\n| timeout\n" }, { "name": "class InternalServerError", "content": "| InternalServerError(message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n|\n| Method resolution order:\n| InternalServerError\n| APIStatusError\n| APIError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data and other attributes defined here:\n|\n| annotations = {}\n|\n| ----------------------------------------------------------------------\n| Methods inherited from APIStatusError:\n|\n| init(self, message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from APIError:\n|\n| code = None\n|\n| param = None\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class InvalidWebhookSignatureError", "content": "| Raised when a webhook signature is invalid, meaning the computed signature does not match the expected signature.\n|\n| Method resolution order:\n| InvalidWebhookSignatureError\n| builtins.ValueError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data descriptors defined here:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.ValueError:\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.ValueError:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class LengthFinishReasonError", "content": "| LengthFinishReasonError(*, completion: 'ChatCompletion') -> 'None'\n|\n| Method resolution order:\n| LengthFinishReasonError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, *, completion: 'ChatCompletion') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {'completion': 'ChatCompletion'}\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class NoneType", "content": "| Methods defined here:\n|\n| bool(self, /)\n| True if self else False\n|\n| repr(self, /)\n| Return repr(self).\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n" }, { "name": "class NotFoundError", "content": "| NotFoundError(message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n|\n| Method resolution order:\n| NotFoundError\n| APIStatusError\n| APIError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data and other attributes defined here:\n|\n| annotations = {'statuscode': 'Literal[404]'}\n|\n| statuscode = 404\n|\n| ----------------------------------------------------------------------\n| Methods inherited from APIStatusError:\n|\n| init(self, message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from APIError:\n|\n| code = None\n|\n| param = None\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class NotGiven", "content": "| For parameters with a meaningful None value, we need to distinguish between\n| the user explicitly passing None, and the user not passing the parameter at\n| all.\n|\n| User code shouldn't need to use notgiven directly.\n|\n| For example:\n|\n| ```py\n| def create(timeout: Timeout | None | NotGiven = notgiven): ...\n|\n|\n| create(timeout=1) # 1s timeout\n| create(timeout=None) # No timeout\n| create() # Default timeout behavior\n| ```\n|\n| Methods defined here:\n|\n| bool(self) -> 'Literal[False]'\n|\n| repr(self) -> 'str'\n| Return repr(self).\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n" }, { "name": "class OAuthError", "content": "| OAuthError(*, response: 'httpx.Response', body: 'object | None') -> 'None'\n|\n| Method resolution order:\n| OAuthError\n| AuthenticationError\n| APIStatusError\n| APIError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, *, response: 'httpx.Response', body: 'object | None') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {'error': 'Optional[OAuthErrorCode]'}\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from AuthenticationError:\n|\n| statuscode = 401\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from APIError:\n|\n| code = None\n|\n| param = None\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class Omit", "content": "| To explicitly omit something from being sent in a request, use `omit`.\n|\n| ```py\n| # as the default `Content-Type` header is `application/json` that will be sent\n| client.post(\"/upload/files\", files={\"file\": b\"my raw file content\"})\n|\n| # you can't explicitly override the header as it has to be dynamically generated\n| # to look something like: 'multipart/form-data; boundary=0d8382fcf5f8c3be01ca2e11002d2983'\n| client.post(..., headers={\"Content-Type\": \"multipart/form-data\"})\n|\n| # instead you can remove the default `application/json` header by passing omit\n| client.post(..., headers={\"Content-Type\": omit})\n| ```\n|\n| Methods defined here:\n|\n| bool(self) -> 'Literal[False]'\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n" }, { "name": "class OpenAI", "content": "| OpenAI(*, apikey: 'str | Callable[[], str] | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, provider: 'Provider | None' = None, baseurl: 'str | httpx.URL | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, maxretries: 'int' = 2, defaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, httpclient: 'httpx.Client | None' = None, strictresponsevalidation: 'bool' = False, enforcecredentials: 'bool' = True) -> 'None'\n|\n| Method resolution order:\n| OpenAI\n| openai.baseclient.SyncAPIClient\n| openai.baseclient.BaseClient\n| typing.Generic\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, *, apikey: 'str | Callable[[], str] | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, provider: 'Provider | None' = None, baseurl: 'str | httpx.URL | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, maxretries: 'int' = 2, defaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, httpclient: 'httpx.Client | None' = None, strictresponsevalidation: 'bool' = False, enforcecredentials: 'bool' = True) -> 'None'\n| Construct a new synchronous OpenAI client instance.\n|\n| This automatically infers the following arguments from their corresponding environment variables if they are not provided:\n| - `apikey` from `OPENAIAPIKEY`\n| - `adminapikey` from `OPENAIADMINKEY`\n| - `organization` from `OPENAIORGID`\n| - `project` from `OPENAIPROJECTID`\n| - `webhooksecret` from `OPENAIWEBHOOKSECRET`\n|\n| When `provider` is supplied, authentication and the base URL are configured by that provider instead.\n|\n| admin = \n| audio = \n| batches = \n| Create large batches of API requests to run asynchronously.\n|\n| beta = \n| chat = \n| completions = \n| Given a prompt, the model will return one or more predicted completions, and can also return the probabilities of alternative tokens at each position.\n|\n| containers = \n| conversations = \n| Manage conversations and conversation items.\n|\n| copy(self, *, apikey: 'str | Callable[[], str] | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, provider: 'Provider | None | NotGiven' = NOTGIVEN, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, baseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, httpclient: 'httpx.Client | None' = None, maxretries: 'int | NotGiven' = NOTGIVEN, defaultheaders: 'Mapping[str, str] | None' = None, setdefaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, setdefaultquery: 'Mapping[str, object] | None' = None, enforcecredentials: 'bool | None' = None, extrakwargs: 'Mapping[str, Any]' = {}) -> 'Self'\n| Create a new client instance re-using the same options given to the current client with optional overriding.\n|\n| embeddings = \n| Get a vector representation of a given input that can be easily consumed by machine learning models and algorithms.\n|\n| evals = \n| Manage and run evals in the OpenAI platform.\n|\n| files = \n| Files are used to upload documents that can be used with features like Assistants and Fine-tuning.\n|\n| finetuning = \n| images = \n| Given a prompt and/or an input image, the model will generate a new image.\n|\n| models = \n| List and describe the various models available in the API.\n|\n| moderations = \n| Given text and/or image inputs, classifies if those inputs are potentially harmful.\n|\n| realtime = \n| responses = \n| skills = \n| uploads = \n| Use Uploads to upload large files in multiple parts.\n|\n| vectorstores = \n| videos = \n| webhooks = \n| withoptions = copy(self, *, apikey: 'str | Callable[[], str] | None' = None, adminapikey: 'str | None' = None, workloadidentity: 'WorkloadIdentity | None' = None, provider: 'Provider | None | NotGiven' = NOTGIVEN, organization: 'str | None' = None, project: 'str | None' = None, webhooksecret: 'str | None' = None, websocketbaseurl: 'str | httpx.URL | None' = None, baseurl: 'str | httpx.URL | None' = None, timeout: 'float | Timeout | None | NotGiven' = NOTGIVEN, httpclient: 'httpx.Client | None' = None, maxretries: 'int | NotGiven' = NOTGIVEN, defaultheaders: 'Mapping[str, str] | None' = None, setdefaultheaders: 'Mapping[str, str] | None' = None, defaultquery: 'Mapping[str, object] | None' = None, setdefaultquery: 'Mapping[str, object] | None' = None, enforcecredentials: 'bool | None' = None, extrakwargs: 'Mapping[str, Any]' = {}) -> 'Self'\n|\n| withrawresponse = \n| withstreamingresponse = \n| ----------------------------------------------------------------------\n| Readonly properties defined here:\n|\n| authheaders\n|\n| defaultheaders\n|\n| qs\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {'provider': 'Provider | None', 'providerruntime...\n|\n| parameters = ()\n|\n| ----------------------------------------------------------------------\n| Methods inherited from openai.baseclient.SyncAPIClient:\n|\n| enter(self: 'T') -> 'T'\n|\n| exit(self, exctype: 'type[BaseException] | None', exc: 'BaseException | None', exctb: 'TracebackType | None') -> 'None'\n|\n| close(self) -> 'None'\n| Close the underlying HTTPX client.\n|\n| The client will *not* be usable after this.\n|\n| delete(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'BinaryTypes | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| get(self, path: 'str', *, castto: 'Type[ResponseT]', options: 'RequestOptions' = {}, stream: 'bool' = False, streamcls: 'type[StreamT] | None' = None) -> 'ResponseT | StreamT'\n|\n| getapilist(self, path: 'str', *, model: 'Type[object]', page: 'Type[SyncPageT]', body: 'Body | None' = None, options: 'RequestOptions' = {}, method: 'str' = 'get') -> 'SyncPageT'\n|\n| isclosed(self) -> 'bool'\n|\n| patch(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'BinaryTypes | None' = None, files: 'RequestFiles | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| post(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'BinaryTypes | None' = None, options: 'RequestOptions' = {}, files: 'RequestFiles | None' = None, stream: 'bool' = False, streamcls: 'type[StreamT] | None' = None) -> 'ResponseT | StreamT'\n|\n| put(self, path: 'str', *, castto: 'Type[ResponseT]', body: 'Body | None' = None, content: 'BinaryTypes | None' = None, files: 'RequestFiles | None' = None, options: 'RequestOptions' = {}) -> 'ResponseT'\n|\n| request(self, castto: 'Type[ResponseT]', options: 'FinalRequestOptions', *, stream: 'bool' = False, streamcls: 'type[StreamT] | None' = None) -> 'ResponseT | StreamT'\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from openai.baseclient.SyncAPIClient:\n|\n| origbases = (openai.baseclient.BaseClient[httpx.Client, openai....\n|\n| ----------------------------------------------------------------------\n| Methods inherited from openai.baseclient.BaseClient:\n|\n| platformheaders(self) -> 'Dict[str, str]'\n|\n| ----------------------------------------------------------------------\n| Readonly properties inherited from openai.baseclient.BaseClient:\n|\n| customauth\n|\n| defaultquery\n|\n| useragent\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from openai.baseclient.BaseClient:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| baseurl\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from typing.Generic:\n|\n| classgetitem(params) from builtins.type\n|\n| initsubclass(*args, kwargs) from builtins.type\n| This method is called when a class is subclassed.\n|\n| The default implementation does nothing. It may be\n| overridden to extend subclasses.\n" }, { "name": "class OpenAIError", "content": "| Method resolution order:\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data descriptors defined here:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {}\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.Exception:\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class PermissionDeniedError", "content": "| PermissionDeniedError(message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n|\n| Method resolution order:\n| PermissionDeniedError\n| APIStatusError\n| APIError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data and other attributes defined here:\n|\n| annotations = {'statuscode': 'Literal[403]'}\n|\n| statuscode = 403\n|\n| ----------------------------------------------------------------------\n| Methods inherited from APIStatusError:\n|\n| init(self, message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from APIError:\n|\n| code = None\n|\n| param = None\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class RateLimitError", "content": "| RateLimitError(message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n|\n| Method resolution order:\n| RateLimitError\n| APIStatusError\n| APIError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data and other attributes defined here:\n|\n| annotations = {'statuscode': 'Literal[429]'}\n|\n| statuscode = 429\n|\n| ----------------------------------------------------------------------\n| Methods inherited from APIStatusError:\n|\n| init(self, message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from APIError:\n|\n| code = None\n|\n| param = None\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class ReconnectingEvent", "content": "| ReconnectingEvent(attempt: 'int', maxattempts: 'int', delay: 'float', closecode: 'int', extraquery: 'Query', extraheaders: 'Headers') -> None\n|\n| Information about a reconnection attempt, passed to the ``onreconnecting`` handler.\n|\n| Methods defined here:\n|\n| delattr(self, name)\n| Implement delattr(self, name).\n|\n| eq(self, other)\n| Return self==value.\n|\n| hash(self)\n| Return hash(self).\n|\n| init(self, attempt: 'int', maxattempts: 'int', delay: 'float', closecode: 'int', extraquery: 'Query', extraheaders: 'Headers') -> None\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| repr(self)\n| Return repr(self).\n|\n| setattr(self, name, value)\n| Implement setattr(self, name, value).\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {'attempt': 'int', 'closecode': 'int', 'delay': 'fl...\n|\n| dataclassfields = {'attempt': Field(name='attempt',type='int',def...\n|\n| dataclassparams = DataclassParams(init=True,repr=True,eq=True,or...\n|\n| matchargs = ('attempt', 'maxattempts', 'delay', 'closecode', 'e...\n" }, { "name": "class ReconnectingOverrides", "content": "| Optional overrides returned from the ``onreconnecting`` handler\n| to customize the next reconnection attempt.\n|\n| Method resolution order:\n| ReconnectingOverrides\n| builtins.dict\n| builtins.object\n|\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {'abort': ForwardRef('bool'), 'extraheaders': Forwa...\n|\n| closed = None\n|\n| extraitems = typingextensions.NoExtraItems\n|\n| mutablekeys = frozenset({'abort', 'extraheaders', 'extraquery'}...\n|\n| optionalkeys = frozenset({'abort', 'extraheaders', 'extraquery'...\n|\n| origbases = (typingextensions.TypedDict,)\n|\n| readonlykeys = frozenset()\n|\n| requiredkeys = frozenset()\n|\n| total = False\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.dict:\n|\n| contains(self, key, /)\n| True if the dictionary has the specified key, else False.\n|\n| delitem(self, key, /)\n| Delete self[key].\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| getitem(...)\n| x.getitem(y) <==> x[y]\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ior(self, value, /)\n| Return self|=value.\n|\n| iter(self, /)\n| Implement iter(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| len(self, /)\n| Return len(self).\n|\n| lt(self, value, /)\n| Return self size of D in memory, in bytes\n|\n| clear(...)\n| D.clear() -> None. Remove all items from D.\n|\n| copy(...)\n| D.copy() -> a shallow copy of D\n|\n| get(self, key, default=None, /)\n| Return the value for key if key is in the dictionary, else default.\n|\n| items(...)\n| D.items() -> a set-like object providing a view on D's items\n|\n| keys(...)\n| D.keys() -> a set-like object providing a view on D's keys\n|\n| pop(...)\n| D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n|\n| If the key is not found, return the default if given; otherwise,\n| raise a KeyError.\n|\n| popitem(self, /)\n| Remove and return a (key, value) pair as a 2-tuple.\n|\n| Pairs are returned in LIFO (last-in, first-out) order.\n| Raises KeyError if the dict is empty.\n|\n| setdefault(self, key, default=None, /)\n| Insert key with a value of default if key is not in the dictionary.\n|\n| Return the value for key if key is in the dictionary, else default.\n|\n| update(...)\n| D.update([E, ]F) -> None. Update D from dict/iterable E and F.\n| If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]\n| If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v\n| In either case, this is followed by: for k in F: D[k] = F[k]\n|\n| values(...)\n| D.values() -> an object providing a view on D's values\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from builtins.dict:\n|\n| classgetitem(...) from typingextensions.TypedDictMeta\n| See PEP 585\n|\n| fromkeys(iterable, value=None, /) from typingextensions.TypedDictMeta\n| Create a new dictionary with keys from iterable and values set to value.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.dict:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from builtins.dict:\n|\n| hash = None\n" }, { "name": "class RequestOptions", "content": "| Method resolution order:\n| RequestOptions\n| builtins.dict\n| builtins.object\n|\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {'extrajson': ForwardRef('AnyMapping'), 'followred...\n|\n| closed = None\n|\n| extraitems = typingextensions.NoExtraItems\n|\n| mutablekeys = frozenset({'extrajson', 'followredirects', 'heade...\n|\n| optionalkeys = frozenset({'extrajson', 'followredirects', 'head...\n|\n| origbases = (typingextensions.TypedDict,)\n|\n| readonlykeys = frozenset()\n|\n| requiredkeys = frozenset()\n|\n| total = False\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.dict:\n|\n| contains(self, key, /)\n| True if the dictionary has the specified key, else False.\n|\n| delitem(self, key, /)\n| Delete self[key].\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| getitem(...)\n| x.getitem(y) <==> x[y]\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ior(self, value, /)\n| Return self|=value.\n|\n| iter(self, /)\n| Implement iter(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| len(self, /)\n| Return len(self).\n|\n| lt(self, value, /)\n| Return self size of D in memory, in bytes\n|\n| clear(...)\n| D.clear() -> None. Remove all items from D.\n|\n| copy(...)\n| D.copy() -> a shallow copy of D\n|\n| get(self, key, default=None, /)\n| Return the value for key if key is in the dictionary, else default.\n|\n| items(...)\n| D.items() -> a set-like object providing a view on D's items\n|\n| keys(...)\n| D.keys() -> a set-like object providing a view on D's keys\n|\n| pop(...)\n| D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n|\n| If the key is not found, return the default if given; otherwise,\n| raise a KeyError.\n|\n| popitem(self, /)\n| Remove and return a (key, value) pair as a 2-tuple.\n|\n| Pairs are returned in LIFO (last-in, first-out) order.\n| Raises KeyError if the dict is empty.\n|\n| setdefault(self, key, default=None, /)\n| Insert key with a value of default if key is not in the dictionary.\n|\n| Return the value for key if key is in the dictionary, else default.\n|\n| update(...)\n| D.update([E, ]F) -> None. Update D from dict/iterable E and F.\n| If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]\n| If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v\n| In either case, this is followed by: for k in F: D[k] = F[k]\n|\n| values(...)\n| D.values() -> an object providing a view on D's values\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from builtins.dict:\n|\n| classgetitem(...) from typingextensions.TypedDictMeta\n| See PEP 585\n|\n| fromkeys(iterable, value=None, /) from typingextensions.TypedDictMeta\n| Create a new dictionary with keys from iterable and values set to value.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.dict:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from builtins.dict:\n|\n| hash = None\n" }, { "name": "class Stream", "content": "| Stream(*, castto: 'type[T]', response: 'httpx.Response', client: 'OpenAI', options: 'Optional[FinalRequestOptions]' = None) -> 'None'\n|\n| Provides the core interface to iterate over a synchronous stream response.\n|\n| Method resolution order:\n| Stream\n| typing.Generic\n| builtins.object\n|\n| Methods defined here:\n|\n| enter(self) -> 'Self'\n|\n| exit(self, exctype: 'type[BaseException] | None', exc: 'BaseException | None', exctb: 'TracebackType | None') -> 'None'\n|\n| init(self, *, castto: 'type[T]', response: 'httpx.Response', client: 'OpenAI', options: 'Optional[FinalRequestOptions]' = None) -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| iter(self) -> 'Iterator[T]'\n|\n| next(self) -> 'T'\n|\n| stream(self) -> 'Iterator[T]'\n|\n| close(self) -> 'None'\n| Close the response and release the connection.\n|\n| Automatically called if the response body is read to completion.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {'decoder': 'SSEBytesDecoder', 'options': 'Optiona...\n|\n| origbases = (typing.Generic[~T],)\n|\n| parameters = (~T,)\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from typing.Generic:\n|\n| classgetitem(params) from builtins.type\n|\n| initsubclass(*args, kwargs) from builtins.type\n| This method is called when a class is subclassed.\n|\n| The default implementation does nothing. It may be\n| overridden to extend subclasses.\n" }, { "name": "class Timeout", "content": "| Timeout(timeout: 'TimeoutTypes | UnsetType' = , *, connect: 'None | float | UnsetType' = , read: 'None | float | UnsetType' = , write: 'None | float | UnsetType' = , pool: 'None | float | UnsetType' = ) -> 'None'\n|\n| Timeout configuration.\n|\n| Usage:\n|\n| Timeout(None) # No timeouts.\n| Timeout(5.0) # 5s timeout on all operations.\n| Timeout(None, connect=5.0) # 5s timeout on connect, no other timeouts.\n| Timeout(5.0, connect=10.0) # 10s timeout on connect. 5s timeout elsewhere.\n| Timeout(5.0, pool=None) # No timeout on acquiring connection from pool.\n| # 5s timeout elsewhere.\n|\n| Methods defined here:\n|\n| eq(self, other: 'typing.Any') -> 'bool'\n| Return self==value.\n|\n| init(self, timeout: 'TimeoutTypes | UnsetType' = , *, connect: 'None | float | UnsetType' = , read: 'None | float | UnsetType' = , write: 'None | float | UnsetType' = , pool: 'None | float | UnsetType' = ) -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| repr(self) -> 'str'\n| Return repr(self).\n|\n| asdict(self) -> 'dict[str, float | None]'\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| hash = None\n\nTransport = class BaseTransport(builtins.object)\n| Methods defined here:\n|\n| enter(self: 'T') -> 'T'\n|\n| exit(self, exctype: 'type[BaseException] | None' = None, excvalue: 'BaseException | None' = None, traceback: 'TracebackType | None' = None) -> 'None'\n|\n| close(self) -> 'None'\n|\n| handlerequest(self, request: 'Request') -> 'Response'\n| Send a single HTTP request and return a response.\n|\n| Developers shouldn't typically ever need to call into this API directly,\n| since the Client class provides all the higher level user-facing API\n| niceties.\n|\n| In order to properly release any network resources, the response\n| stream should *either* be consumed immediately, with a call to\n| `response.stream.read()`, or else the `handlerequest` call should\n| be followed with a try/finally block to ensuring the stream is\n| always closed.\n|\n| Example usage:\n|\n| with httpx.HTTPTransport() as transport:\n| req = httpx.Request(\n| method=b\"GET\",\n| url=(b\"https\", b\"www.example.com\", 443, b\"/\"),\n| headers=[(b\"Host\", b\"www.example.com\")],\n| )\n| resp = transport.handlerequest(req)\n| body = resp.stream.read()\n| print(resp.statuscode, resp.headers, body)\n|\n|\n| Takes a `Request` instance as the only argument.\n|\n| Returns a `Response` instance.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n" }, { "name": "class UnprocessableEntityError", "content": "| UnprocessableEntityError(message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n|\n| Method resolution order:\n| UnprocessableEntityError\n| APIStatusError\n| APIError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data and other attributes defined here:\n|\n| annotations = {'statuscode': 'Literal[422]'}\n|\n| statuscode = 422\n|\n| ----------------------------------------------------------------------\n| Methods inherited from APIStatusError:\n|\n| init(self, message: 'str', *, response: 'httpx.Response', body: 'object | None') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from APIError:\n|\n| code = None\n|\n| param = None\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class WebSocketConnectionClosedError", "content": "| WebSocketConnectionClosedError(message: 'str', *, unsentmessages: 'list[str]') -> 'None'\n|\n| Raised when a WebSocket connection closes with unsent messages.\n|\n| Method resolution order:\n| WebSocketConnectionClosedError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, message: 'str', *, unsentmessages: 'list[str]') -> 'None'\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {'unsentmessages': 'list[str]'}\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class WebSocketQueueFullError", "content": "| Raised when the outgoing WebSocket message queue exceeds its byte-size limit.\n|\n| Method resolution order:\n| WebSocketQueueFullError\n| OpenAIError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data and other attributes defined here:\n|\n| annotations = {}\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from OpenAIError:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.Exception:\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" } ] }, "FUNCTIONS": { "content": "", "subsections": [ { "name": "file_from_path", "content": "" } ] }, "DATA": { "content": "DEFAULTCONNECTIONLIMITS = Limits(maxconnections=1000, maxkeepalive...\nDEFAULTMAXRETRIES = 2\nDEFAULTTIMEOUT = Timeout(connect=5.0, read=600, write=600, pool=600)\nNOTGIVEN = NOTGIVEN\nProxiesTypes = typing.Union[str, httpx.Proxy, typing.Dict[Forwa...ng.U...\nall = ['types', 'version', 'title', 'NoneType', 'Transport...\nannotations = {'bedrockapikey': 'str | None', 'client': 'OpenA...\ntitle = 'openai'\nnotgiven = NOTGIVEN\nomit = \n", "subsections": [] }, "VERSION": { "content": "2.44.0\n", "subsections": [] }, "FILE": { "content": "/home/chedong/.local/lib/python3.10/site-packages/openai/init.py\n\n", "subsections": [] } }, "summary": "openai - # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.", "flags": [], "examples": [], "see_also": [] }