Package: jarvisbot-python
JarvisBot Python API library[!IMPORTANT]
This SDK is fork from OpenAI repository[tag 1.12.0], we try our best to make it compatible with OpenAI, but it may change in the future.The OpenAI Python library provides convenient access to the OpenAI REST API from any Python 3.7+
application. The library includes type definitions for all request params and response fields,
and offers both synchronous and asynchronous clients powered byhttpx.It is generated from ourOpenAPI specificationwithStainless.DocumentationThe REST API documentation can be foundon platform.openai.com. The full API of this library can be found inapi.md.Installation[!IMPORTANT]
The SDK was rewritten in v1, which was released November 6th 2023. See thev1 migration guide, which includes scripts to automatically update your code.pipinstalljarvisbotUsageThe full API of this library can be found inapi.md.importosfromjarvisbotimportOpenAIclient=OpenAI(# This is the default and can be omittedapi_key=os.environ.get("OPENAI_API_KEY"),)chat_completion=client.chat.completions.create(messages=[{"role":"user","content":"Say this is a test",}],model="gpt-3.5-turbo",)While you can provide anapi_keykeyword argument,
we recommend usingpython-dotenvto addOPENAI_API_KEY="My API Key"to your.envfile
so that your API Key is not stored in source control.Async usageSimply importAsyncOpenAIinstead ofOpenAIand useawaitwith each API call:importosimportasynciofromjarvisbotimportAsyncOpenAIclient=AsyncOpenAI(# This is the default and can be omittedapi_key=os.environ.get("OPENAI_API_KEY"),)asyncdefmain()->None:chat_completion=awaitclient.chat.completions.create(messages=[{"role":"user","content":"Say this is a test",}],model="gpt-3.5-turbo",)asyncio.run(main())Functionality between the synchronous and asynchronous clients is otherwise identical.Streaming ResponsesWe provide support for streaming responses using Server Side Events (SSE).fromjarvisbotimportOpenAIclient=OpenAI()stream=client.chat.completions.create(model="gpt-4",messages=[{"role":"user","content":"Say this is a test"}],stream=True,)forchunkinstream:print(chunk.choices[0].delta.contentor"",end="")The async client uses the exact same interface.fromjarvisbotimportAsyncOpenAIclient=AsyncOpenAI()asyncdefmain():stream=awaitclient.chat.completions.create(model="gpt-4",messages=[{"role":"user","content":"Say this is a test"}],stream=True,)asyncforchunkinstream:print(chunk.choices[0].delta.contentor"",end="")asyncio.run(main())Module-level client[!IMPORTANT]
We highly recommend instantiating client instances instead of relying on the global client.We also expose a global client instance that is accessible in a similar fashion to versions prior to v1.importjarvisbot# optional; defaults to `os.environ['OPENAI_API_KEY']`jarvisbot.api_key='...'# all client options can be configured just like the `OpenAI` instantiation counterpartjarvisbot.base_url="https://..."jarvisbot.default_headers={"x-foo":"true"}completion=jarvisbot.chat.completions.create(model="gpt-4",messages=[{"role":"user","content":"How do I output all files in a directory using Python?",},],)print(completion.choices[0].message.content)The API is the exact same as the standard client instance based API.This is intended to be used within REPLs or notebooks for faster iteration,notin application code.We recommend that you always instantiate a client (e.g., withclient = OpenAI()) in application code because:It can be difficult to reason about where client options are configuredIt's not possible to change certain client options without potentially causing race conditionsIt's harder to mock for testing purposesIt's not possible to control cleanup of network connectionsUsing typesNested request parameters areTypedDicts. Responses arePydantic models, which provide helper methods for things like:Serializing back into JSON,model.model_dump_json(indent=2, exclude_unset=True)Converting to a dictionary,model.model_dump(exclude_unset=True)Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, setpython.analysis.typeCheckingModetobasic.PaginationList methods in the OpenAI API are paginated.This library provides auto-paginating iterators with each list response, so you do not have to request successive pages manually:importjarvisbotclient=OpenAI()all_jobs=[]# Automatically fetches more pages as needed.forjobinclient.fine_tuning.jobs.list(limit=20,):# Do something with job hereall_jobs.append(job)print(all_jobs)Or, asynchronously:importasyncioimportjarvisbotclient=AsyncOpenAI()asyncdefmain()->None:all_jobs=[]# Iterate through items across all pages, issuing requests as needed.asyncforjobinclient.fine_tuning.jobs.list(limit=20,):all_jobs.append(job)print(all_jobs)asyncio.run(main())Alternatively, you can use the.has_next_page(),.next_page_info(), or.get_next_page()methods for more granular control working with pages:first_page=awaitclient.fine_tuning.jobs.list(limit=20,)iffirst_page.has_next_page():print(f"will fetch next page using these details:{first_page.next_page_info()}")next_page=awaitfirst_page.get_next_page()print(f"number of items we just fetched:{len(next_page.data)}")# Remove `await` for non-async usage.Or just work directly with the returned data:first_page=awaitclient.fine_tuning.jobs.list(limit=20,)print(f"next page cursor:{first_page.after}")# => "next page cursor: ..."forjobinfirst_page.data:print(job.id)# Remove `await` for non-async usage.Nested paramsNested parameters are dictionaries, typed usingTypedDict, for example:fromjarvisbotimportOpenAIclient=OpenAI()completion=client.chat.completions.create(messages=[{"role":"user","content":"Can you generate an example json object describing a fruit?",}],model="gpt-3.5-turbo-1106",response_format={"type":"json_object"},)File UploadsRequest parameters that correspond to file uploads can be passed asbytes, aPathLikeinstance or a tuple of(filename, contents, media type).frompathlibimportPathfromjarvisbotimportOpenAIclient=OpenAI()client.files.create(file=Path("input.jsonl"),purpose="fine-tune",)The async client uses the exact same interface. If you pass aPathLikeinstance, the file contents will be read asynchronously automatically.Handling errorsWhen the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass ofopenai.APIConnectionErroris raised.When the API returns a non-success status code (that is, 4xx or 5xx
response), a subclass ofopenai.APIStatusErroris raised, containingstatus_codeandresponseproperties.All errors inherit fromopenai.APIError.importjarvisbotfromjarvisbotimportOpenAIclient=OpenAI()try:client.fine_tuning.jobs.create(model="gpt-3.5-turbo",training_file="file-abc123",)exceptjarvisbot.APIConnectionErrorase:print("The server could not be reached")print(e.__cause__)# an underlying Exception, likely raised within httpx.exceptjarvisbot.RateLimitErrorase:print("A 429 status code was received; we should back off a bit.")exceptjarvisbot.APIStatusErrorase:print("Another non-200-range status code was received")print(e.status_code)print(e.response)Error codes are as followed:Status CodeError Type400BadRequestError401AuthenticationError403PermissionDeniedError404NotFoundError422UnprocessableEntityError429RateLimitError>=500InternalServerErrorN/AAPIConnectionErrorRetriesCertain errors are automatically retried 2 times by default, with a short exponential backoff.
Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
429 Rate Limit, and >=500 Internal errors are all retried by default.You can use themax_retriesoption to configure or disable retry settings:fromjarvisbotimportOpenAI# Configure the default for all requests:client=OpenAI(# default is 2max_retries=0,)# Or, configure per-request:client.with_options(max_retries=5).chat.completions.create(messages=[{"role":"user","content":"How can I get the name of the current day in Node.js?",}],model="gpt-3.5-turbo",)TimeoutsBy default requests time out after 10 minutes. You can configure this with atimeoutoption,
which accepts a float or anhttpx.Timeoutobject:fromjarvisbotimportOpenAI# Configure the default for all requests:client=OpenAI(# 20 seconds (default is 10 minutes)timeout=20.0,)# More granular control:client=OpenAI(timeout=httpx.Timeout(60.0,read=5.0,write=10.0,connect=2.0),)# Override per-request:client.with_options(timeout=5*1000).chat.completions.create(messages=[{"role":"user","content":"How can I list all files in a directory using Python?",}],model="gpt-3.5-turbo",)On timeout, anAPITimeoutErroris thrown.Note that requests that time out areretried twice by default.AdvancedLoggingWe use the standard libraryloggingmodule.You can enable logging by setting the environment variableOPENAI_LOGtodebug.$exportOPENAI_LOG=debugHow to tell whetherNonemeansnullor missingIn an API response, a field may be explicitlynull, or missing entirely; in either case, its value isNonein this library. You can differentiate the two cases with.model_fields_set:ifresponse.my_fieldisNone:if'my_field'notinresponse.model_fields_set:print('Got json like{}, without a "my_field" key present at all.')else:print('Got json like {"my_field": null}.')Accessing raw response data (e.g. headers)The "raw" Response object can be accessed by prefixing.with_raw_response.to any HTTP method call, e.g.,fromjarvisbotimportOpenAIclient=OpenAI()response=client.chat.completions.with_raw_response.create(messages=[{"role":"user","content":"Say this is a test",}],model="gpt-3.5-turbo",)print(response.headers.get('X-My-Header'))completion=response.parse()# get the object that `chat.completions.create()` would have returnedprint(completion)These methods return anLegacyAPIResponseobject. This is a legacy class as we're changing it slightly in the next major version.For the sync client this will mostly be the same with the exception
ofcontent&textwill be methods instead of properties. In the
async client, all methods will be async.A migration script will be provided & the migration in general should
be smooth..with_streaming_responseThe above interface eagerly reads the full response body when you make the request, which may not always be what you want.To stream the response body, use.with_streaming_responseinstead, which requires a context manager and only reads the response body once you call.read(),.text(),.json(),.iter_bytes(),.iter_text(),.iter_lines()or.parse(). In the async client, these are async methods.As such,.with_streaming_responsemethods return a differentAPIResponseobject, and the async client returns anAsyncAPIResponseobject.withclient.chat.completions.with_streaming_response.create(messages=[{"role":"user","content":"Say this is a test",}],model="gpt-3.5-turbo",)asresponse:print(response.headers.get("X-My-Header"))forlineinresponse.iter_lines():print(line)The context manager is required so that the response will reliably be closed.Configuring the HTTP clientYou can directly override thehttpx clientto customize it for your use case, including:Support for proxiesCustom transportsAdditionaladvancedfunctionalityimporthttpxfromjarvisbotimportOpenAIclient=OpenAI(# Or use the `OPENAI_BASE_URL` env varbase_url="http://my.test.server.example.com:8083",http_client=httpx.Client(proxies="http://my.test.proxy.example.com",transport=httpx.HTTPTransport(local_address="0.0.0.0"),),)Managing HTTP resourcesBy default the library closes underlying HTTP connections whenever the client isgarbage collected. You can manually close the client using the.close()method if desired, or with a context manager that closes when exiting.Microsoft Azure OpenAITo use this library withAzure OpenAI, use theAzureOpenAIclass instead of theOpenAIclass.[!IMPORTANT]
The Azure API shape differs from the core API shape which means that the static types for responses / params
won't always be correct.fromjarvisbotimportAzureOpenAI# gets the API Key from environment variable AZURE_OPENAI_API_KEYclient=AzureOpenAI(# https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#rest-api-versioningapi_version="2023-07-01-preview",# https://learn.microsoft.com/en-us/azure/cognitive-services/openai/how-to/create-resource?pivots=web-portal#create-a-resourceazure_endpoint="https://example-endpoint.openai.azure.com",)completion=client.chat.completions.create(model="deployment-name",# e.g. gpt-35-instantmessages=[{"role":"user","content":"How do I output all files in a directory using Python?",},],)print(completion.model_dump_json(indent=2))In addition to the options provided in the baseOpenAIclient, the following options are provided:azure_endpoint(or theAZURE_OPENAI_ENDPOINTenvironment variable)azure_deploymentapi_version(or theOPENAI_API_VERSIONenvironment variable)azure_ad_token(or theAZURE_OPENAI_AD_TOKENenvironment variable)azure_ad_token_providerAn example of using the client with Azure Active Directory can be foundhere.VersioningThis package generally followsSemVerconventions, though certain backwards-incompatible changes may be released as minor versions:Changes that only affect static types, without breaking runtime behavior.Changes to library internals which are technically public but not intended or documented for external use.(Please open a GitHub issue to let us know if you are relying on such internals).Changes that we do not expect to impact the vast majority of users in practice.We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.We are keen for your feedback; please open anissuewith questions, bugs, or suggestions.RequirementsPython 3.7 or higher.