GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

openai/openai-python

Public

mirrored from https://github.com/openai/openai-pythonAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
01c5ec6d3d3ea578ff2178f796be3e50630e544e

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

openai-python/tests/api_resources/chat

tests/api_resources/chat/test_completions.py

480lines · modecode

RawDownload
Latest commit unavailable.
1# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
2
3from __future__ import annotations
4
5import os
6from typing import Any, cast
7
8import pytest
9
10from openai import OpenAI, AsyncOpenAI
11from tests.utils import assert_matches_type
12from openai.types.chat import (
13 ChatCompletion,
14)
15
16base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
17
18
19class TestCompletions:
20 parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
21
22 @parametrize
23 def test_method_create_overload_1(self, client: OpenAI) -> None:
24 completion = client.chat.completions.create(
25 messages=[
26 {
27 "content": "string",
28 "role": "developer",
29 }
30 ],
31 model="gpt-4o",
32 )
33 assert_matches_type(ChatCompletion, completion, path=["response"])
34
35 @parametrize
36 def test_method_create_with_all_params_overload_1(self, client: OpenAI) -> None:
37 completion = client.chat.completions.create(
38 messages=[
39 {
40 "content": "string",
41 "role": "developer",
42 "name": "name",
43 }
44 ],
45 model="gpt-4o",
46 audio={
47 "format": "wav",
48 "voice": "alloy",
49 },
50 frequency_penalty=-2,
51 function_call="none",
52 functions=[
53 {
54 "name": "name",
55 "description": "description",
56 "parameters": {"foo": "bar"},
57 }
58 ],
59 logit_bias={"foo": 0},
60 logprobs=True,
61 max_completion_tokens=0,
62 max_tokens=0,
63 metadata={"foo": "string"},
64 modalities=["text"],
65 n=1,
66 parallel_tool_calls=True,
67 prediction={
68 "content": "string",
69 "type": "content",
70 },
71 presence_penalty=-2,
72 reasoning_effort="low",
73 response_format={"type": "text"},
74 seed=0,
75 service_tier="auto",
76 stop="string",
77 store=True,
78 stream=False,
79 stream_options={"include_usage": True},
80 temperature=1,
81 tool_choice="none",
82 tools=[
83 {
84 "function": {
85 "name": "name",
86 "description": "description",
87 "parameters": {"foo": "bar"},
88 "strict": True,
89 },
90 "type": "function",
91 }
92 ],
93 top_logprobs=0,
94 top_p=1,
95 user="user-1234",
96 )
97 assert_matches_type(ChatCompletion, completion, path=["response"])
98
99 @parametrize
100 def test_raw_response_create_overload_1(self, client: OpenAI) -> None:
101 response = client.chat.completions.with_raw_response.create(
102 messages=[
103 {
104 "content": "string",
105 "role": "developer",
106 }
107 ],
108 model="gpt-4o",
109 )
110
111 assert response.is_closed is True
112 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
113 completion = response.parse()
114 assert_matches_type(ChatCompletion, completion, path=["response"])
115
116 @parametrize
117 def test_streaming_response_create_overload_1(self, client: OpenAI) -> None:
118 with client.chat.completions.with_streaming_response.create(
119 messages=[
120 {
121 "content": "string",
122 "role": "developer",
123 }
124 ],
125 model="gpt-4o",
126 ) as response:
127 assert not response.is_closed
128 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
129
130 completion = response.parse()
131 assert_matches_type(ChatCompletion, completion, path=["response"])
132
133 assert cast(Any, response.is_closed) is True
134
135 @parametrize
136 def test_method_create_overload_2(self, client: OpenAI) -> None:
137 completion_stream = client.chat.completions.create(
138 messages=[
139 {
140 "content": "string",
141 "role": "developer",
142 }
143 ],
144 model="gpt-4o",
145 stream=True,
146 )
147 completion_stream.response.close()
148
149 @parametrize
150 def test_method_create_with_all_params_overload_2(self, client: OpenAI) -> None:
151 completion_stream = client.chat.completions.create(
152 messages=[
153 {
154 "content": "string",
155 "role": "developer",
156 "name": "name",
157 }
158 ],
159 model="gpt-4o",
160 stream=True,
161 audio={
162 "format": "wav",
163 "voice": "alloy",
164 },
165 frequency_penalty=-2,
166 function_call="none",
167 functions=[
168 {
169 "name": "name",
170 "description": "description",
171 "parameters": {"foo": "bar"},
172 }
173 ],
174 logit_bias={"foo": 0},
175 logprobs=True,
176 max_completion_tokens=0,
177 max_tokens=0,
178 metadata={"foo": "string"},
179 modalities=["text"],
180 n=1,
181 parallel_tool_calls=True,
182 prediction={
183 "content": "string",
184 "type": "content",
185 },
186 presence_penalty=-2,
187 reasoning_effort="low",
188 response_format={"type": "text"},
189 seed=0,
190 service_tier="auto",
191 stop="string",
192 store=True,
193 stream_options={"include_usage": True},
194 temperature=1,
195 tool_choice="none",
196 tools=[
197 {
198 "function": {
199 "name": "name",
200 "description": "description",
201 "parameters": {"foo": "bar"},
202 "strict": True,
203 },
204 "type": "function",
205 }
206 ],
207 top_logprobs=0,
208 top_p=1,
209 user="user-1234",
210 )
211 completion_stream.response.close()
212
213 @parametrize
214 def test_raw_response_create_overload_2(self, client: OpenAI) -> None:
215 response = client.chat.completions.with_raw_response.create(
216 messages=[
217 {
218 "content": "string",
219 "role": "developer",
220 }
221 ],
222 model="gpt-4o",
223 stream=True,
224 )
225
226 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
227 stream = response.parse()
228 stream.close()
229
230 @parametrize
231 def test_streaming_response_create_overload_2(self, client: OpenAI) -> None:
232 with client.chat.completions.with_streaming_response.create(
233 messages=[
234 {
235 "content": "string",
236 "role": "developer",
237 }
238 ],
239 model="gpt-4o",
240 stream=True,
241 ) as response:
242 assert not response.is_closed
243 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
244
245 stream = response.parse()
246 stream.close()
247
248 assert cast(Any, response.is_closed) is True
249
250
251class TestAsyncCompletions:
252 parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
253
254 @parametrize
255 async def test_method_create_overload_1(self, async_client: AsyncOpenAI) -> None:
256 completion = await async_client.chat.completions.create(
257 messages=[
258 {
259 "content": "string",
260 "role": "developer",
261 }
262 ],
263 model="gpt-4o",
264 )
265 assert_matches_type(ChatCompletion, completion, path=["response"])
266
267 @parametrize
268 async def test_method_create_with_all_params_overload_1(self, async_client: AsyncOpenAI) -> None:
269 completion = await async_client.chat.completions.create(
270 messages=[
271 {
272 "content": "string",
273 "role": "developer",
274 "name": "name",
275 }
276 ],
277 model="gpt-4o",
278 audio={
279 "format": "wav",
280 "voice": "alloy",
281 },
282 frequency_penalty=-2,
283 function_call="none",
284 functions=[
285 {
286 "name": "name",
287 "description": "description",
288 "parameters": {"foo": "bar"},
289 }
290 ],
291 logit_bias={"foo": 0},
292 logprobs=True,
293 max_completion_tokens=0,
294 max_tokens=0,
295 metadata={"foo": "string"},
296 modalities=["text"],
297 n=1,
298 parallel_tool_calls=True,
299 prediction={
300 "content": "string",
301 "type": "content",
302 },
303 presence_penalty=-2,
304 reasoning_effort="low",
305 response_format={"type": "text"},
306 seed=0,
307 service_tier="auto",
308 stop="string",
309 store=True,
310 stream=False,
311 stream_options={"include_usage": True},
312 temperature=1,
313 tool_choice="none",
314 tools=[
315 {
316 "function": {
317 "name": "name",
318 "description": "description",
319 "parameters": {"foo": "bar"},
320 "strict": True,
321 },
322 "type": "function",
323 }
324 ],
325 top_logprobs=0,
326 top_p=1,
327 user="user-1234",
328 )
329 assert_matches_type(ChatCompletion, completion, path=["response"])
330
331 @parametrize
332 async def test_raw_response_create_overload_1(self, async_client: AsyncOpenAI) -> None:
333 response = await async_client.chat.completions.with_raw_response.create(
334 messages=[
335 {
336 "content": "string",
337 "role": "developer",
338 }
339 ],
340 model="gpt-4o",
341 )
342
343 assert response.is_closed is True
344 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
345 completion = response.parse()
346 assert_matches_type(ChatCompletion, completion, path=["response"])
347
348 @parametrize
349 async def test_streaming_response_create_overload_1(self, async_client: AsyncOpenAI) -> None:
350 async with async_client.chat.completions.with_streaming_response.create(
351 messages=[
352 {
353 "content": "string",
354 "role": "developer",
355 }
356 ],
357 model="gpt-4o",
358 ) as response:
359 assert not response.is_closed
360 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
361
362 completion = await response.parse()
363 assert_matches_type(ChatCompletion, completion, path=["response"])
364
365 assert cast(Any, response.is_closed) is True
366
367 @parametrize
368 async def test_method_create_overload_2(self, async_client: AsyncOpenAI) -> None:
369 completion_stream = await async_client.chat.completions.create(
370 messages=[
371 {
372 "content": "string",
373 "role": "developer",
374 }
375 ],
376 model="gpt-4o",
377 stream=True,
378 )
379 await completion_stream.response.aclose()
380
381 @parametrize
382 async def test_method_create_with_all_params_overload_2(self, async_client: AsyncOpenAI) -> None:
383 completion_stream = await async_client.chat.completions.create(
384 messages=[
385 {
386 "content": "string",
387 "role": "developer",
388 "name": "name",
389 }
390 ],
391 model="gpt-4o",
392 stream=True,
393 audio={
394 "format": "wav",
395 "voice": "alloy",
396 },
397 frequency_penalty=-2,
398 function_call="none",
399 functions=[
400 {
401 "name": "name",
402 "description": "description",
403 "parameters": {"foo": "bar"},
404 }
405 ],
406 logit_bias={"foo": 0},
407 logprobs=True,
408 max_completion_tokens=0,
409 max_tokens=0,
410 metadata={"foo": "string"},
411 modalities=["text"],
412 n=1,
413 parallel_tool_calls=True,
414 prediction={
415 "content": "string",
416 "type": "content",
417 },
418 presence_penalty=-2,
419 reasoning_effort="low",
420 response_format={"type": "text"},
421 seed=0,
422 service_tier="auto",
423 stop="string",
424 store=True,
425 stream_options={"include_usage": True},
426 temperature=1,
427 tool_choice="none",
428 tools=[
429 {
430 "function": {
431 "name": "name",
432 "description": "description",
433 "parameters": {"foo": "bar"},
434 "strict": True,
435 },
436 "type": "function",
437 }
438 ],
439 top_logprobs=0,
440 top_p=1,
441 user="user-1234",
442 )
443 await completion_stream.response.aclose()
444
445 @parametrize
446 async def test_raw_response_create_overload_2(self, async_client: AsyncOpenAI) -> None:
447 response = await async_client.chat.completions.with_raw_response.create(
448 messages=[
449 {
450 "content": "string",
451 "role": "developer",
452 }
453 ],
454 model="gpt-4o",
455 stream=True,
456 )
457
458 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
459 stream = response.parse()
460 await stream.close()
461
462 @parametrize
463 async def test_streaming_response_create_overload_2(self, async_client: AsyncOpenAI) -> None:
464 async with async_client.chat.completions.with_streaming_response.create(
465 messages=[
466 {
467 "content": "string",
468 "role": "developer",
469 }
470 ],
471 model="gpt-4o",
472 stream=True,
473 ) as response:
474 assert not response.is_closed
475 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
476
477 stream = await response.parse()
478 await stream.close()
479
480 assert cast(Any, response.is_closed) is True
481