v1.0.0 Beta

[hallacy]

Important

v1.0.0 is live! Get started by following the migration guide here:
#742

[lxuechen]

Removed support for Azure
There are subtle differences in how the API behaves which means the types we define won't always be accurate

What would be the recommended way to query OAI models on Azure?

[rattrayalex]

Great, glad to hear it worked!

Sorry, I can't help you with the Azure API.

[takekazuomi]

@rattrayalex
If Azure OpenAI is no longer supported, libraries such as LangChain and Semantic Kernel will need to be changed, and I am worried that this will cause confusion. If you know of a good place to talk about Azure OpenAI and OpenAI compatibility, please let me know.

[rattrayalex]

Those libraries will need to make several changes to accommodate this release, including how they connect to Azure (which is still possible; see example linked above).

This is a fine place to discuss the topic!

[trrwilson]

Just to add a note from the Azure OpenAI side: we're investigating options for great, portable Python use with the v1 SDK right now and working with the OpenAI team to coordinate. The manual workaround that @rattrayalex linked is a great resource for bridging the gap and we'll share updates on how we'll further improve ergonomics and Azure feature completeness as those details become available.

[RobertCraigie]

The latest pre-release (v1.0.0-rc1) includes support for Azure!

The docs can be found here: https://github.com/openai/openai-python/tree/v1#microsoft-azure-openai

[a-v-ershov]

Are you going to add an ability to make concurrent calls to the API through the client?
E.g. make an async function to request completions.

[RobertCraigie]

What would you be looking for from a function we define? You can already make concurrent async calls to the API using asyncio.gather

import asyncio
from openai import AsyncOpenAI
from openai.types.chat import ChatCompletion

client = AsyncOpenAI()

async def first_completion() -> ChatCompletion:
    return await client.chat.completions.create(
        model="gpt-4",
        messages=[
            {
                "role": "user",
                "content": "How are you doing ChatGPT?",
            },
        ],
    )

async def second_completion() -> ChatCompletion:
    return await client.chat.completions.create(
        model="gpt-4",
        messages=[
            {
                "role": "user",
                "content": "Say this is a test",
            },
        ],
    )

async def main() -> None:
    first, second = await asyncio.gather(first_completion(), second_completion())
    print("----- first response -----")
    print(first.choices[0].message.content)

    print("----- second response -----")
    print(second.choices[0].message.content)


asyncio.run(main())

[ShantanuNair]

@hallacy This is great, great news!

Quick question: Would this issue, #387 relating to discrepancy in request timeout settings between async/sync calls be fixed now?

[RobertCraigie]

Yes that issue is fixed, the synchronous and asynchronous clients both accept the same timeout types which can be configured with high granularity. https://www.python-httpx.org/advanced/#fine-tuning-the-configuration

[ShantanuNair]

Would we be able to get a changelog or similar so that we may test certain features/changes? I'm particularly concerned about changes relating to:

1. Long running requests and passing sessions
2. Automatic session closing every 3 minutes, I believe this has been removed?
3. Other changes to retry/timeout mechanisms as these are going to impact Langchain development downstream, and imo langchain could be a large source of bugs/fixes reports from users

[RobertCraigie]

We'll look into this, thanks for reporting!

[rickyrobinett]

Hey @RobertCraigie - I'm on the Cloudflare DevRel team. If you need any help investigating on our side, let me know.

[ShantanuNair]

@rickyrobinett I have several incidents logged with Cloudflare 502s. They are extremely critical issues as 1) We get billed and 2) no generations despite waiting a long long time. If I can be of any help as well, do let me know. It is something I have spent quite some time trying to overcome, and would appreciate being able to bounce off ideas/find the root cause.

[matteosdocsity]

HI all can someone clarify if timeouts are billed? Here appears clear from the Azuere OpenAI forum that timeout is not billed.
How to change the default mechanism to stop retries?

[rattrayalex]

For API questions, e.g. timeouts, see either the Azure or OpenAI developer forums (depending on the API you are using).

To stop retries, pass max_retries=0, as documented here.

[ShantanuNair]

@hwchase17 @hinthornw @rlancemartin Apologies if this is noise - but I think this is a core change that fixes many current issues with the openai client, and would need an effort to upgrade/test within langchain.

[NgWaiKong]

"You can now instantiate a client" this is really helpful, love it and wanna say BIG THANK YOU.

And wondering if there is approach or plan for the Azure support? I think more developers will need to customize based on the new library version. This is great for the diversity of the open-source community, but at the same time, there's a lot of redundant work, and the quality can't be guaranteed. I'm wondering if it would be better for there to be official unified support?

[RobertCraigie]

We're looking into how Azure can be supported! #631 (reply in thread)

[vega99]

If you are removing support for Azure, will there be another library to work with Azure?

[rattrayalex]

Let's keep discussion of Azure support in this thread, which we'll update with our thinking around that soon.

[viveknair]

Great work on the new Python SDK!

We have an observability product (Gentrace) that ties into the openai package transparently. I've implemented the necessary changes for the synchronous version thanks to the below exports.

Would it be possible to export the asynchronous versions of these resources?

from ._module_client import chat as chat
from ._module_client import audio as audio
from ._module_client import edits as edits
from ._module_client import files as files
from ._module_client import images as images
from ._module_client import models as models
from ._module_client import embeddings as embeddings
from ._module_client import fine_tunes as fine_tunes
from ._module_client import completions as completions
from ._module_client import fine_tuning as fine_tuning
from ._module_client import moderations as moderations

Alternatively, is there a way to get a direct handle to the async class definitions? (e.g. AsyncCompletions)

[RobertCraigie]

Our thinking behind providing a "module client" for synchronous calls is that it can be quite nice when running one-off scripts or REPLs. For more complicated use cases we intend for you to use the client instance based API.

Is there a reason that using client instances wouldn't work for your use case?

Alternatively, is there a way to get a direct handle to the async class definitions? (e.g. AsyncCompletions)

Sorry I don't quite understand what you're asking here, could you explain further?

[Garett-MacGowan]

Is it possible to get the rate limit information from the headers in this client? https://platform.openai.com/docs/guides/rate-limits/overview

In the old client, it was possible to get headers from non-streaming requests using the below (hacky, but possible).

response = openai.Completion.create(**kwargs)
response._headers

[Garett-MacGowan]

Thanks. Any idea how soon this might be expected? The lack of this functionality is blocking for some advanced users.

[RobertCraigie]

I expect we'll have a release out today or tomorrow with support for passing in a custom httpx Client. Unfortunately I'm unsure when .as_raw_response() will land.

[rattrayalex]

(To clarify, we do expect .as_raw_response() or an equivalent to land before v1 is GA)

[RobertCraigie]

We've published a new beta version that supports passing a http_client argument! https://github.com/openai/openai-python/tree/v1?tab=readme-ov-file#configuring-the-http-client

[Garett-MacGowan]

Thanks!

[harupy]

Is there an ETA for the release?

[rattrayalex]

We're planning to release this in the coming weeks; please give it a try now if you're able!

[NgWaiKong]

Amazing, thank you for the great work!

[morganmcg1]

@hallacy , Morgan from Weights & Biases here. We're happy to jump in and contribute on the W&B migration if ye need?

cc @shawnlewis @tcapelle @ash0ts

[RobertCraigie]

Thanks Morgan! We're looking into porting the existing WandbLogger.sync() method to the new structure and have a working synchronous implementation.

Do you think it would be helpful / feasible for us to also provide an async implementation?

[morganmcg1]

thanks @RobertCraigie, I haven't heard of users complaining that the wandb sync was slow or blocking for them, it should be pretty quick to upload to W&B as its only uploading metrics. But also, yeah async could be a nice addition for some users.

One higher-priority feature I'd suggest/ask/volunteer for would be to add the ability to automatically sync the fine-tune metrics to W&B when the training is complete. The existing implementation is a little awkward as you have to first manually check if the fine-tune is complete, and then call openai wandb sync.

ideally a user could do something like client.fine_tuning.jobs.create(wandb_api_key="ABC123") and have their results automatically pushed to W&B once training is complete. Would that be too much?

[rattrayalex]

Hi @morganmcg1 (and @shawnlewis @tcapelle @ash0ts), after discussing this internally (with @jhallard and others), we've decided that Weights & Biases functionality should live in the wandb python package instead of the openai package.

This should be roughly as straightforward as porting the WandbLogger class from our repo to yours (making openai an optional dependency), e.g.,

import wandb

wandb_client = wandb.Api()

wandb_client.openai.sync_fine_tunes() # uses the OPENAI_API_KEY env var, and does exactly what `openai.WandbLogger.sync()` does today

Of course, you're welcome to change the behavior or add new functionality, such as not making OpenAI API requests within the wandb SDK, or adding a function to create a fine tuning job & then push to W&B once it's ready.

Some imagined sample code, depending on how much OpenAI interaction you want to bake into your SDK:

import openai
import wandb

openai_client = openai.OpenAI()
wandb_client = wandb.Api()

# here, the user could filter themselves in various ways
fine_tunes = [
  job.id for job 
  in openai_client.fine_tuning.jobs.list()
  if job.status == 'succeeded'
]

wandb_client.openai.sync_fine_tunes(job_ids=fine_tunes)

# or, for the use-case you highlighted:
job = openai_client.fine_tuning.jobs.create(…)
wandb_client.openai.upload_job_when_done(job_id=job.id)

We'd love to make this a smooth transition for W&B users; send me an email to coordinate.

[pamelafox]

Just tried out the new SDK, happy to see the move over to a Client() for configuration! Is this SDK in a stable enough design to be shown in videos? I was going to record a video using the OpenAI SDK and I figure I might as well use the new one if it's ready enough.

[rattrayalex]

Thank you Pamela! I think that'd be sane, yes! The one area where we're likely to iterate is Azure OpenAI - we're hoping to add a nicer way to connect there – so if your video is likely to demo that, you may want to hold off for a bit.

[rgbkrk]

Started a conversion on the chatlab library here: rgbkrk/chatlab#96

Let me know if you see any pitfalls related to our usage here. I am really glad to toss the hand crafted types I put in for the previous version of this API.

[rgbkrk]

Migrated and shipped chatlab@v1.0.0-alpha.27!

It was a really clean transition. Thanks for this well-typed API.

[Bikatr7]

Hi. Sorry to bother, do we have an estimated “official” launch for this? I have some old code running off the old format, Kudasai, and it needs to function on a major project before November.

Would this being released break my old code? I'm not entirely familiar with how these things work, I apologize and thanks if you could answer.

[RobertCraigie]

This release would break your code but if you can't migrate to the new version you can continue to use the current version of the library. You'll just need to make sure that you're specifying a version range when you install dependencies, for example

pip install 'openai<1'

[Bikatr7]

Alright thanks. Appreciate it.

[jakobdylanc]

Any major downsides sticking with "import openai" instead of "from openai import OpenAI"? Is it a much heavier import or negligible?

[RobertCraigie]

Are you talking about using the module client vs the client instance based API?

If so, we highly recommend using the client instance based API, the reasoning is outlined here https://github.com/openai/openai-python/tree/v1?tab=readme-ov-file#module-level-client. But in short, global configuration makes it difficult to test, reason about where configuration happens and efficiently manage HTTP resources.

The module client is only intended for usage within REPLs or one-off scripts to provide a faster iteration speed, for anything other than that you should use the client API.

Is it a much heavier import

There is no difference here, the same modules & symbols will be imported regardless of import openai or from openai import OpenAI.

[kristapratico]

Question on Audio: the file keyword-only argument is typed as follows:

openai-python/src/openai/_types.py

Lines 37 to 47 in 34e0d94

	FileContent = Union[IO[bytes], bytes]
	FileTypes = Union[
	# file (or bytes)
	FileContent,
	# (filename, file (or bytes))
	Tuple[Optional[str], FileContent],
	# (filename, file (or bytes), content_type)
	Tuple[Optional[str], FileContent, Optional[str]],
	# (filename, file (or bytes), content_type, headers)
	Tuple[Optional[str], FileContent, Optional[str], Mapping[str, str]],
	]

I can pass IO[bytes] or the file tuple just fine, but when I pass just bytes, I'm seeing some service-side validation performed (my guess is that it's not seeing a filename/extension in the request and assumes invalid data):

>>> from pathlib import Path
>>> from openai import OpenAI
>>> client = OpenAI(api_key="sk-xxx")
>>> file_bytes = Path("hello.m4a").read_bytes()
>>> result = client.audio.transcriptions.create(file=file_bytes, model="whisper-1")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Users\krpratic\openai-python\src\openai\resources\audio\transcriptions.py", line 87, in create
    return self._post(
           ^^^^^^^^^^^
  File "C:\Users\krpratic\openai-python\src\openai\_base_client.py", line 1087, in post
    return cast(ResponseT, self.request(cast_to, opts, stream=stream, stream_cls=stream_cls))
                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Users\krpratic\openai-python\src\openai\_base_client.py", line 882, in request
    return self._request(
           ^^^^^^^^^^^^^^
  File "C:\Users\krpratic\openai-python\src\openai\_base_client.py", line 924, in _request
    raise self._make_status_error_from_response(err.response) from None
openai.BadRequestError: Error code: 400 - {'error': {'message': "Unrecognized file format. Supported formats: ['flac', 'm4a', 'mp3', 'mp4', 'mpeg', 'mpga', 'oga', 'ogg', 'wav', 'webm']", 'type': 'invalid_request_error', 'param': None, 'code': None}}

Should bytes be valid here?

[rattrayalex]

This is a good call-out; cc @RobertCraigie.

The good news is that in the next beta release (if it hasn't gone out already) you'll be able to just pass a Path object and it'll include the filename too, like so:

>>> from pathlib import Path
>>> from openai import OpenAI
>>> client = OpenAI(api_key="sk-xxx")
>>> result = client.audio.transcriptions.create(file=Path("hello.m4a"), model="whisper-1")

[nccx]

Does it support multimodal? If not, is there such a plan?

[rattrayalex]

The SDK will support all features that are generally available in the API.

[schnerd]

OpenAI's API team will be talking about future directions for the API at the upcoming DevDay: https://devday.openai.com/

[Tom-Standen]

Hey, nice job with the release.

Unfortunately, I still can't maintain an open connection between requests - am I missing something?

I'm attempting to instantiate the client on FastAPI app startup and use dependency injection to reuse it in all my routes. I've tried defining it as a separate global variable too.

Apologies in advance if I'm doing something stupid

@app.on_event("startup")
async def startup_event():
app.state.openai_client = openai.AsyncClient(
api_key = os.getenv("OPENAI_API_KEY"), # <- default
max_retries = 2, # <- default
timeout = 90.0,
http_client=httpx.AsyncClient(http2=True)

Tom

[Tom-Standen]

Hi Rob, thanks for looking into this for me and for spotting the bug!

Specifying httpcore==0.18.0 httpx==0.25.0 has done the trick and I've recreated your logs.

I think what was throwing me was that I expected the connection to stay open ~5s and I think it lives a little less than that. Not an issue, I just wasn't testing it properly.

Thanks for the help
Tom

[rattrayalex]

Ah, I do wonder if we should set a longer keepalive_expiry, seems the default is 5s which may be a little tight for how people use this API, especially if it counts from the start of requests instead of the end…

[Tom-Standen]

Ooh, I would definitely get behind that...

To give you a taste, our use-case is a chat app where at this current keepalive_expiry often isn't long enough to keep connections open between user messages.

When we have concurrent users they tend to keep the connection open between them but our DAU numbers are still < 100 so not everyone is lucky enough to be using the app whilst someone else is.

Far from a critical issue for us, and should disappear as we grow but for now, if it's on the table, i'd support a longer keepalive_expiry

[rattrayalex]

Thanks Tom! Is there a keepalive expiry that you think would be too long? what would you expect here?

[Tom-Standen]

Not really a too long from my end.

Users typically take between 30s - 120s to reply depending on their proficiency in the language they are trying to learn.

Not sure if extending it out to minutes has implications at your end but wouldn't be a problem for us

[Garett-MacGowan]

Heads up, 1.0.0.rc1 and 1.0.0.rc2 seem to be broken with Python 3.8.0.

1.0.0b3 works fine.

Error is:

TypeError: 'ABCMeta' object is not subscriptable

It occurs at line 192 of _types.py in 1.0.0rc2

FileContent = Union[IO[bytes], bytes, PathLike[str]]

[rattrayalex]

Thank you very much for reporting this! I've reproduced and identified a fix. We hope to have that up shortly.

[rattrayalex]

This fix has been released in 1.0.0rc3!

[mrbullwinkle]

Added an issue/question regarding dropping embedding_utils.py breaking semantic text search: #676

[Imadnajam]

Good Work

[winstonpurnomo]

Am unable to use the response_format: { type: "json_object" } argument.

Is it passing it in to:

client.chat.completions.create(
            model=self.model,
            messages=messages,
            response_format={ 'type': 'json_object' },
            timeout=10
        )

?

It tells me Completions.create() got an unexpected keyword argument 'responseFormat'

[schnerd]

The new features announced at DevDay will be released in v1.1.0 in the next couple hours.

[chadlieberman-flywire]

Is there any special permissions required for the new features? Or are the API endpoints still being rolled out?

openai.NotFoundError: Error code: 404 - {'error': {'message': 'Invalid URL (POST /v1/assistants)', 'type': 'invalid_request_error', 'param': None, 'code': None}}

[rattrayalex]

They were still being rolled out, and should be available now. Note that response_format: json_object is only available in the the newly released models.

[marban]

Json response works fine now, but I'm curious — Is there no way to provide a template for the response?. In other words, do I still have to provide the Json structure in the prompt and hope for the best?

[rattrayalex]

For that kind of API call, yes. For something more structured, I'd suggest using functions or tools, perhaps with our runFunctions or runTools helper methods.

Since you just want the model to respond with structured output, you can pass a single function like provideResult and pass function_call: {name: 'provideResult'}.

Using the new gpt-4-1106-preview model will help guarantee JSON output, but the runFunctions and runTools helpers have some auto-recovery mechanisms built in.

Does that help?

[jakobdylanc]

Context: https://platform.openai.com/docs/guides/safety-best-practices/end-user-ids

To my understanding this used to be "name" but now it's "user". However when doing chat completion with models like gpt-3.5-turbo-16k and gpt-4 you still need to use "name". And trying to use "user" with new models like gpt-4-1106-preview results in an error.

Also, between gpt-4-1106-preview and gpt-4-vision-preview, only the former can access the information within "name". In other words, when I put some text in the "name" field and tell gpt-4-vision-preview to recite it, it can't. All other models I've tested can do this.

[jakobdylanc]

Sorry I misspoke here. The link I provided is for "user" which is a parameter of client.completions.create. But what I'm talking about is "name" which was a key/value entry in the message object, e.g:

{"role": "user", "content": "My name is Bob", "name": "Bob"}

[rattrayalex]

Thanks for letting us know, I've passed that along!

(for future reference, this repo is intended for python SDK issues, not model/API issues).

[matteosdocsity]

which is the new name for the old ServiceUnavailableError?

[RobertCraigie]

We don't actually have a distinct error class that is raised in that case, we'll currently raise APIStatusError with status_code == 503 which you could check. Will look into adding it.

[mirrorcoloured]

I am facing persistent SSL errors as of 1.0.0.

On 0.28.1 this works successfully (with the OPENAI_API_KEY environment variable set):

import openai
comp = openai.ChatCompletion.create(
    model='gpt-3.5-turbo',
    messages=[{'role': 'user', 'content': 'Hello world'}],
)
print(comp['choices'][0]['message']['content'])

On 1.0.0 the equivalent code is giving me an error:

import openai
client = openai.OpenAI()
comp = client.chat.completions.create(
    model='gpt-3.5-turbo',
    messages=[{'role': 'user', 'content': 'Hello world'}],
)
print(comp['choices'][0]['message']['content'])

---------------------------------------------------------------------------
---------------------------------------------------------------------------
SSLCertVerificationError                  Traceback (most recent call last)
File c:\Users\me\Miniconda3\lib\site-packages\httpcore\_exceptions.py:10, in map_exceptions(map)
      9 try:
---> 10     yield
     11 except Exception as exc:  # noqa: PIE786

File c:\Users\me\Miniconda3\lib\site-packages\httpcore\_backends\sync.py:168, in SyncStream.start_tls(self, ssl_context, server_hostname, timeout)
    167         self.close()
--> 168         raise exc
    169 return SyncStream(sock)

File c:\Users\me\Miniconda3\lib\site-packages\httpcore\_backends\sync.py:163, in SyncStream.start_tls(self, ssl_context, server_hostname, timeout)
    162         self._sock.settimeout(timeout)
--> 163         sock = ssl_context.wrap_socket(
    164             self._sock, server_hostname=server_hostname
    165         )
    166 except Exception as exc:  # pragma: nocover

File c:\Users\me\Miniconda3\lib\ssl.py:500, in SSLContext.wrap_socket(self, sock, server_side, do_handshake_on_connect, suppress_ragged_eofs, server_hostname, session)
    494 def wrap_socket(self, sock, server_side=False,
    495                 do_handshake_on_connect=True,
    496                 suppress_ragged_eofs=True,
    497                 server_hostname=None, session=None):
    498     # SSLSocket class handles server_hostname encoding before it calls
    499     # ctx._wrap_socket()
--> 500     return self.sslsocket_class._create(
    501         sock=sock,
    502         server_side=server_side,
    503         do_handshake_on_connect=do_handshake_on_connect,
    504         suppress_ragged_eofs=suppress_ragged_eofs,
    505         server_hostname=server_hostname,
    506         context=self,
    507         session=session
    508     )

File c:\Users\me\Miniconda3\lib\ssl.py:1040, in SSLSocket._create(cls, sock, server_side, do_handshake_on_connect, suppress_ragged_eofs, server_hostname, context, session)
   1039             raise ValueError("do_handshake_on_connect should not be specified for non-blocking sockets")
-> 1040         self.do_handshake()
   1041 except (OSError, ValueError):

File c:\Users\me\Miniconda3\lib\ssl.py:1309, in SSLSocket.do_handshake(self, block)
   1308         self.settimeout(None)
-> 1309     self._sslobj.do_handshake()
   1310 finally:

SSLCertVerificationError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:1129)

The above exception was the direct cause of the following exception:

ConnectError                              Traceback (most recent call last)
File c:\Users\me\Miniconda3\lib\site-packages\httpx\_transports\default.py:66, in map_httpcore_exceptions()
     65 try:
---> 66     yield
     67 except Exception as exc:
...
   (...)
    904     stream_cls=stream_cls,
    905 )

APIConnectionError: Connection error.

I am running this through a corporate network and have faced SSL errors which were previously resolved by various methods:

1. Downloading the root certificate when accessing openai and setting REQUESTS_CA_BUNDLE to point to that certificate
2. Adding the aforementioned certificate to certifi's cacert.pem
3. Installing pip_system_certs

While these methods worked on previous versions, they no longer do as of 1.0.0. Is there a new recommended workaround while working on company-owned machines/networks?

[rattrayalex]

You'll likely need to pass a custom http_client that configures SSL: https://www.python-httpx.org/advanced/#ssl-certificates

The readme on this project has documentation on passing your own httpx instance as http_client, and the docs above can tell you how to configure httpx for custom SSL, but the details will likely depend on your situation.

I'm sorry for the extra work, and best of luck!

[byroncoetsee]

Hey hey :)
Not sure if it's too late or the wrong place to post but I'm seeing a breaking difference between v.0.28.1 and ^v1.0.0
Any version above 1.0.0 causes any firebase functions to hangup immediately.

Reproducible by simply:

from openai import OpenAI
initialize_app()
firestore_client = firestore.Client()
openai_client = OpenAI()

@https_fn.on_request(cors=options.CorsOptions(cors_origins="*", cors_methods=["get"]))
def test(req: https_fn.Request) -> https_fn.Response:
    return 'worked?', 200

(missing some imports there for firebase functions and emulators)
It'll build, but the second the function is called by HTTP (and I assume openai is initialised), the connection immediately dies.

Downgrading to v0.28.1 fixes it.

[RobertCraigie]

Are you saying that your function hangs even when you're not making a request with the openai client? Just when importing it?

[byroncoetsee]

Hey Rob thanks for the fast response. If I understand correctly, yes I don't even have to make a request to openai (beyond initialising it - but I don't think that makes a call)

So I'll start the emulators, and they'll start fine. No errors yet.
I then just browse to the URL http://127.0.0.1:5001/.../test and the console of the emulators just say the socket hung up and nothing further. Browser eventually times out and throws an error.

[rattrayalex]

This doesn't sound like an issue with the OpenAI client? Though you may want to double-check that you're providing an API Key. You can check this by doing openai_client = OpenAI(api_key="test").

[byroncoetsee]

I tried that too, just didn't include that way of setting the API key in my example code. Used the env variable instead. Doesn't work.
Also, if the API key weren't provided correctly, it would throw an error, which it isn't doing (confirmed this by removing the key from env - throws an error as expected)

If I remove the openai code, things work fine.
If I use <v1.0.0, things work fine.

The only time things break is when I use >v1.0.0

Sounds like an OpenAI issue.

[rattrayalex]

Very strange.

Do you get a stacktrace? Can you add logging just before and after importing the library, and upon entering your handler? What if you import OpenAI but don't instantiate a client?

[Undertone0809]

I think this kind of sdk design is very beautiful, can you share how to design an sdk like openai? Or where can I see relevant technology sharing? Recently, I also need to develop a client, and I want to refer to the design of openai.

[rattrayalex]

Thanks, that's very kind of you!

Unfortunately, we haven't yet blogged about the principles behind our SDK design, but we plan to do so soon. You can follow https://twitter.com/StainlessAPI for updates there.

If you have an OpenAPI spec for a REST API, you can get similarly designed SDKs from the same provider at stainlessapi.com.

[TamimLikhon]

from openai import OpenAI
client = OpenAI()

OpenAI.api_key = 'my_api'


completion = client.chat.completions.create(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Hello!"}
  ]
)

print(completion.choices[0].message)

error:
getting bunch of errors, and also it saying that incorrect api but its not.. I am newbie +_+ please help on my silly mistake by providing the correct code and solution peace +__+

[pamelafox]

Try passing api_key as an argument to OpenAI() on your second line, and delete the third.

…

On Fri, May 24, 2024 at 10:51 AM TamimLikhon ***@***.***> wrote: from openai import OpenAIclient = OpenAI() OpenAI.api_key = 'my_api' completion = client.chat.completions.create( model="gpt-3.5-turbo", messages=[ {"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": "Hello!"} ] ) print(completion.choices[0].message) error: getting bunch of errors, and also it saying that incorrect api but its not.. I am newbie +_+ please help on my silly mistake by providing the correct code and solution peace +__+ — Reply to this email directly, view it on GitHub <#631 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AACIQUXMRPYAHMPTFTL245DZD54ZLAVCNFSM6AAAAAA5M7QJ6KVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TKNJQGM4TO> . You are receiving this because you were mentioned.Message ID: ***@***.***>