main
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 httpx
9import pytest
10from respx import MockRouter
11
12import openai._legacy_response as _legacy_response
13from openai import OpenAI, AsyncOpenAI
14from tests.utils import assert_matches_type
15from openai.types import (
16 Video,
17 VideoDeleteResponse,
18)
19from openai._utils import assert_signatures_in_sync
20from openai.pagination import SyncConversationCursorPage, AsyncConversationCursorPage
21
22# pyright: reportDeprecated=false
23
24base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
25
26
27class TestVideos:
28 parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
29
30 @parametrize
31 def test_method_create(self, client: OpenAI) -> None:
32 video = client.videos.create(
33 prompt="x",
34 )
35 assert_matches_type(Video, video, path=["response"])
36
37 @parametrize
38 def test_method_create_with_all_params(self, client: OpenAI) -> None:
39 video = client.videos.create(
40 prompt="x",
41 input_reference=b"raw file contents",
42 model="sora-2",
43 seconds="4",
44 size="720x1280",
45 )
46 assert_matches_type(Video, video, path=["response"])
47
48 @parametrize
49 def test_raw_response_create(self, client: OpenAI) -> None:
50 response = client.videos.with_raw_response.create(
51 prompt="x",
52 )
53
54 assert response.is_closed is True
55 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
56 video = response.parse()
57 assert_matches_type(Video, video, path=["response"])
58
59 @parametrize
60 def test_streaming_response_create(self, client: OpenAI) -> None:
61 with client.videos.with_streaming_response.create(
62 prompt="x",
63 ) as response:
64 assert not response.is_closed
65 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
66
67 video = response.parse()
68 assert_matches_type(Video, video, path=["response"])
69
70 assert cast(Any, response.is_closed) is True
71
72 @parametrize
73 def test_method_retrieve(self, client: OpenAI) -> None:
74 video = client.videos.retrieve(
75 "video_123",
76 )
77 assert_matches_type(Video, video, path=["response"])
78
79 @parametrize
80 def test_raw_response_retrieve(self, client: OpenAI) -> None:
81 response = client.videos.with_raw_response.retrieve(
82 "video_123",
83 )
84
85 assert response.is_closed is True
86 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
87 video = response.parse()
88 assert_matches_type(Video, video, path=["response"])
89
90 @parametrize
91 def test_streaming_response_retrieve(self, client: OpenAI) -> None:
92 with client.videos.with_streaming_response.retrieve(
93 "video_123",
94 ) as response:
95 assert not response.is_closed
96 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
97
98 video = response.parse()
99 assert_matches_type(Video, video, path=["response"])
100
101 assert cast(Any, response.is_closed) is True
102
103 @parametrize
104 def test_path_params_retrieve(self, client: OpenAI) -> None:
105 with pytest.raises(ValueError, match=r"Expected a non-empty value for `video_id` but received ''"):
106 client.videos.with_raw_response.retrieve(
107 "",
108 )
109
110 @parametrize
111 def test_method_list(self, client: OpenAI) -> None:
112 video = client.videos.list()
113 assert_matches_type(SyncConversationCursorPage[Video], video, path=["response"])
114
115 @parametrize
116 def test_method_list_with_all_params(self, client: OpenAI) -> None:
117 video = client.videos.list(
118 after="after",
119 limit=0,
120 order="asc",
121 )
122 assert_matches_type(SyncConversationCursorPage[Video], video, path=["response"])
123
124 @parametrize
125 def test_raw_response_list(self, client: OpenAI) -> None:
126 response = client.videos.with_raw_response.list()
127
128 assert response.is_closed is True
129 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
130 video = response.parse()
131 assert_matches_type(SyncConversationCursorPage[Video], video, path=["response"])
132
133 @parametrize
134 def test_streaming_response_list(self, client: OpenAI) -> None:
135 with client.videos.with_streaming_response.list() as response:
136 assert not response.is_closed
137 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
138
139 video = response.parse()
140 assert_matches_type(SyncConversationCursorPage[Video], video, path=["response"])
141
142 assert cast(Any, response.is_closed) is True
143
144 @parametrize
145 def test_method_delete(self, client: OpenAI) -> None:
146 video = client.videos.delete(
147 "video_123",
148 )
149 assert_matches_type(VideoDeleteResponse, video, path=["response"])
150
151 @parametrize
152 def test_raw_response_delete(self, client: OpenAI) -> None:
153 response = client.videos.with_raw_response.delete(
154 "video_123",
155 )
156
157 assert response.is_closed is True
158 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
159 video = response.parse()
160 assert_matches_type(VideoDeleteResponse, video, path=["response"])
161
162 @parametrize
163 def test_streaming_response_delete(self, client: OpenAI) -> None:
164 with client.videos.with_streaming_response.delete(
165 "video_123",
166 ) as response:
167 assert not response.is_closed
168 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
169
170 video = response.parse()
171 assert_matches_type(VideoDeleteResponse, video, path=["response"])
172
173 assert cast(Any, response.is_closed) is True
174
175 @parametrize
176 def test_path_params_delete(self, client: OpenAI) -> None:
177 with pytest.raises(ValueError, match=r"Expected a non-empty value for `video_id` but received ''"):
178 client.videos.with_raw_response.delete(
179 "",
180 )
181
182 @parametrize
183 @pytest.mark.respx(base_url=base_url)
184 def test_method_download_content(self, client: OpenAI, respx_mock: MockRouter) -> None:
185 respx_mock.get("/videos/video_123/content").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
186 video = client.videos.download_content(
187 video_id="video_123",
188 )
189 assert isinstance(video, _legacy_response.HttpxBinaryResponseContent)
190 assert video.json() == {"foo": "bar"}
191
192 @parametrize
193 @pytest.mark.respx(base_url=base_url)
194 def test_method_download_content_with_all_params(self, client: OpenAI, respx_mock: MockRouter) -> None:
195 respx_mock.get("/videos/video_123/content").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
196 video = client.videos.download_content(
197 video_id="video_123",
198 variant="video",
199 )
200 assert isinstance(video, _legacy_response.HttpxBinaryResponseContent)
201 assert video.json() == {"foo": "bar"}
202
203 @parametrize
204 @pytest.mark.respx(base_url=base_url)
205 def test_raw_response_download_content(self, client: OpenAI, respx_mock: MockRouter) -> None:
206 respx_mock.get("/videos/video_123/content").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
207
208 response = client.videos.with_raw_response.download_content(
209 video_id="video_123",
210 )
211
212 assert response.is_closed is True
213 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
214 video = response.parse()
215 assert_matches_type(_legacy_response.HttpxBinaryResponseContent, video, path=["response"])
216
217 @parametrize
218 @pytest.mark.respx(base_url=base_url)
219 def test_streaming_response_download_content(self, client: OpenAI, respx_mock: MockRouter) -> None:
220 respx_mock.get("/videos/video_123/content").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
221 with client.videos.with_streaming_response.download_content(
222 video_id="video_123",
223 ) as response:
224 assert not response.is_closed
225 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
226
227 video = response.parse()
228 assert_matches_type(bytes, video, path=["response"])
229
230 assert cast(Any, response.is_closed) is True
231
232 @parametrize
233 @pytest.mark.respx(base_url=base_url)
234 def test_path_params_download_content(self, client: OpenAI) -> None:
235 with pytest.raises(ValueError, match=r"Expected a non-empty value for `video_id` but received ''"):
236 client.videos.with_raw_response.download_content(
237 video_id="",
238 )
239
240 @parametrize
241 def test_method_remix(self, client: OpenAI) -> None:
242 video = client.videos.remix(
243 video_id="video_123",
244 prompt="x",
245 )
246 assert_matches_type(Video, video, path=["response"])
247
248 @parametrize
249 def test_raw_response_remix(self, client: OpenAI) -> None:
250 response = client.videos.with_raw_response.remix(
251 video_id="video_123",
252 prompt="x",
253 )
254
255 assert response.is_closed is True
256 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
257 video = response.parse()
258 assert_matches_type(Video, video, path=["response"])
259
260 @parametrize
261 def test_streaming_response_remix(self, client: OpenAI) -> None:
262 with client.videos.with_streaming_response.remix(
263 video_id="video_123",
264 prompt="x",
265 ) as response:
266 assert not response.is_closed
267 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
268
269 video = response.parse()
270 assert_matches_type(Video, video, path=["response"])
271
272 assert cast(Any, response.is_closed) is True
273
274 @parametrize
275 def test_path_params_remix(self, client: OpenAI) -> None:
276 with pytest.raises(ValueError, match=r"Expected a non-empty value for `video_id` but received ''"):
277 client.videos.with_raw_response.remix(
278 video_id="",
279 prompt="x",
280 )
281
282
283class TestAsyncVideos:
284 parametrize = pytest.mark.parametrize(
285 "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
286 )
287
288 @parametrize
289 async def test_method_create(self, async_client: AsyncOpenAI) -> None:
290 video = await async_client.videos.create(
291 prompt="x",
292 )
293 assert_matches_type(Video, video, path=["response"])
294
295 @parametrize
296 async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
297 video = await async_client.videos.create(
298 prompt="x",
299 input_reference=b"raw file contents",
300 model="sora-2",
301 seconds="4",
302 size="720x1280",
303 )
304 assert_matches_type(Video, video, path=["response"])
305
306 @parametrize
307 async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
308 response = await async_client.videos.with_raw_response.create(
309 prompt="x",
310 )
311
312 assert response.is_closed is True
313 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
314 video = response.parse()
315 assert_matches_type(Video, video, path=["response"])
316
317 @parametrize
318 async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
319 async with async_client.videos.with_streaming_response.create(
320 prompt="x",
321 ) as response:
322 assert not response.is_closed
323 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
324
325 video = await response.parse()
326 assert_matches_type(Video, video, path=["response"])
327
328 assert cast(Any, response.is_closed) is True
329
330 @parametrize
331 async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
332 video = await async_client.videos.retrieve(
333 "video_123",
334 )
335 assert_matches_type(Video, video, path=["response"])
336
337 @parametrize
338 async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
339 response = await async_client.videos.with_raw_response.retrieve(
340 "video_123",
341 )
342
343 assert response.is_closed is True
344 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
345 video = response.parse()
346 assert_matches_type(Video, video, path=["response"])
347
348 @parametrize
349 async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
350 async with async_client.videos.with_streaming_response.retrieve(
351 "video_123",
352 ) as response:
353 assert not response.is_closed
354 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
355
356 video = await response.parse()
357 assert_matches_type(Video, video, path=["response"])
358
359 assert cast(Any, response.is_closed) is True
360
361 @parametrize
362 async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
363 with pytest.raises(ValueError, match=r"Expected a non-empty value for `video_id` but received ''"):
364 await async_client.videos.with_raw_response.retrieve(
365 "",
366 )
367
368 @parametrize
369 async def test_method_list(self, async_client: AsyncOpenAI) -> None:
370 video = await async_client.videos.list()
371 assert_matches_type(AsyncConversationCursorPage[Video], video, path=["response"])
372
373 @parametrize
374 async def test_method_list_with_all_params(self, async_client: AsyncOpenAI) -> None:
375 video = await async_client.videos.list(
376 after="after",
377 limit=0,
378 order="asc",
379 )
380 assert_matches_type(AsyncConversationCursorPage[Video], video, path=["response"])
381
382 @parametrize
383 async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
384 response = await async_client.videos.with_raw_response.list()
385
386 assert response.is_closed is True
387 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
388 video = response.parse()
389 assert_matches_type(AsyncConversationCursorPage[Video], video, path=["response"])
390
391 @parametrize
392 async def test_streaming_response_list(self, async_client: AsyncOpenAI) -> None:
393 async with async_client.videos.with_streaming_response.list() as response:
394 assert not response.is_closed
395 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
396
397 video = await response.parse()
398 assert_matches_type(AsyncConversationCursorPage[Video], video, path=["response"])
399
400 assert cast(Any, response.is_closed) is True
401
402 @parametrize
403 async def test_method_delete(self, async_client: AsyncOpenAI) -> None:
404 video = await async_client.videos.delete(
405 "video_123",
406 )
407 assert_matches_type(VideoDeleteResponse, video, path=["response"])
408
409 @parametrize
410 async def test_raw_response_delete(self, async_client: AsyncOpenAI) -> None:
411 response = await async_client.videos.with_raw_response.delete(
412 "video_123",
413 )
414
415 assert response.is_closed is True
416 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
417 video = response.parse()
418 assert_matches_type(VideoDeleteResponse, video, path=["response"])
419
420 @parametrize
421 async def test_streaming_response_delete(self, async_client: AsyncOpenAI) -> None:
422 async with async_client.videos.with_streaming_response.delete(
423 "video_123",
424 ) as response:
425 assert not response.is_closed
426 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
427
428 video = await response.parse()
429 assert_matches_type(VideoDeleteResponse, video, path=["response"])
430
431 assert cast(Any, response.is_closed) is True
432
433 @parametrize
434 async def test_path_params_delete(self, async_client: AsyncOpenAI) -> None:
435 with pytest.raises(ValueError, match=r"Expected a non-empty value for `video_id` but received ''"):
436 await async_client.videos.with_raw_response.delete(
437 "",
438 )
439
440 @parametrize
441 @pytest.mark.respx(base_url=base_url)
442 async def test_method_download_content(self, async_client: AsyncOpenAI, respx_mock: MockRouter) -> None:
443 respx_mock.get("/videos/video_123/content").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
444 video = await async_client.videos.download_content(
445 video_id="video_123",
446 )
447 assert isinstance(video, _legacy_response.HttpxBinaryResponseContent)
448 assert video.json() == {"foo": "bar"}
449
450 @parametrize
451 @pytest.mark.respx(base_url=base_url)
452 async def test_method_download_content_with_all_params(
453 self, async_client: AsyncOpenAI, respx_mock: MockRouter
454 ) -> None:
455 respx_mock.get("/videos/video_123/content").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
456 video = await async_client.videos.download_content(
457 video_id="video_123",
458 variant="video",
459 )
460 assert isinstance(video, _legacy_response.HttpxBinaryResponseContent)
461 assert video.json() == {"foo": "bar"}
462
463 @parametrize
464 @pytest.mark.respx(base_url=base_url)
465 async def test_raw_response_download_content(self, async_client: AsyncOpenAI, respx_mock: MockRouter) -> None:
466 respx_mock.get("/videos/video_123/content").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
467
468 response = await async_client.videos.with_raw_response.download_content(
469 video_id="video_123",
470 )
471
472 assert response.is_closed is True
473 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
474 video = response.parse()
475 assert_matches_type(_legacy_response.HttpxBinaryResponseContent, video, path=["response"])
476
477 @parametrize
478 @pytest.mark.respx(base_url=base_url)
479 async def test_streaming_response_download_content(self, async_client: AsyncOpenAI, respx_mock: MockRouter) -> None:
480 respx_mock.get("/videos/video_123/content").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
481 async with async_client.videos.with_streaming_response.download_content(
482 video_id="video_123",
483 ) as response:
484 assert not response.is_closed
485 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
486
487 video = await response.parse()
488 assert_matches_type(bytes, video, path=["response"])
489
490 assert cast(Any, response.is_closed) is True
491
492 @parametrize
493 @pytest.mark.respx(base_url=base_url)
494 async def test_path_params_download_content(self, async_client: AsyncOpenAI) -> None:
495 with pytest.raises(ValueError, match=r"Expected a non-empty value for `video_id` but received ''"):
496 await async_client.videos.with_raw_response.download_content(
497 video_id="",
498 )
499
500 @parametrize
501 async def test_method_remix(self, async_client: AsyncOpenAI) -> None:
502 video = await async_client.videos.remix(
503 video_id="video_123",
504 prompt="x",
505 )
506 assert_matches_type(Video, video, path=["response"])
507
508 @parametrize
509 async def test_raw_response_remix(self, async_client: AsyncOpenAI) -> None:
510 response = await async_client.videos.with_raw_response.remix(
511 video_id="video_123",
512 prompt="x",
513 )
514
515 assert response.is_closed is True
516 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
517 video = response.parse()
518 assert_matches_type(Video, video, path=["response"])
519
520 @parametrize
521 async def test_streaming_response_remix(self, async_client: AsyncOpenAI) -> None:
522 async with async_client.videos.with_streaming_response.remix(
523 video_id="video_123",
524 prompt="x",
525 ) as response:
526 assert not response.is_closed
527 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
528
529 video = await response.parse()
530 assert_matches_type(Video, video, path=["response"])
531
532 assert cast(Any, response.is_closed) is True
533
534 @parametrize
535 async def test_path_params_remix(self, async_client: AsyncOpenAI) -> None:
536 with pytest.raises(ValueError, match=r"Expected a non-empty value for `video_id` but received ''"):
537 await async_client.videos.with_raw_response.remix(
538 video_id="",
539 prompt="x",
540 )
541
542
543@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"])
544def test_create_and_poll_method_in_sync(sync: bool, client: OpenAI, async_client: AsyncOpenAI) -> None:
545 checking_client: OpenAI | AsyncOpenAI = client if sync else async_client
546
547 assert_signatures_in_sync(
548 checking_client.videos.create,
549 checking_client.videos.create_and_poll,
550 exclude_params={"extra_headers", "extra_query", "extra_body", "timeout"},
551 )