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
51e7ebb1a662aedc613cf26eca415d43fedba846

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

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