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
v1.8.0

Branches

Tags

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

Clone

HTTPS

Download ZIP

openai-python/tests/api_resources

tests/api_resources/test_completions.py

260lines · modecode

RawDownload
Latest commit unavailable.
1# File generated from our OpenAPI spec by Stainless.
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 import Completion
13from openai._client import OpenAI, AsyncOpenAI
14
15base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
16api_key = "My API Key"
17
18
19class TestCompletions:
20 strict_client = OpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=True)
21 loose_client = OpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=False)
22 parametrize = pytest.mark.parametrize("client", [strict_client, loose_client], ids=["strict", "loose"])
23
24 @parametrize
25 def test_method_create_overload_1(self, client: OpenAI) -> None:
26 completion = client.completions.create(
27 model="string",
28 prompt="This is a test.",
29 )
30 assert_matches_type(Completion, completion, path=["response"])
31
32 @parametrize
33 def test_method_create_with_all_params_overload_1(self, client: OpenAI) -> None:
34 completion = client.completions.create(
35 model="string",
36 prompt="This is a test.",
37 best_of=0,
38 echo=True,
39 frequency_penalty=-2,
40 logit_bias={"foo": 0},
41 logprobs=0,
42 max_tokens=16,
43 n=1,
44 presence_penalty=-2,
45 seed=-9223372036854776000,
46 stop="\n",
47 stream=False,
48 suffix="test.",
49 temperature=1,
50 top_p=1,
51 user="user-1234",
52 )
53 assert_matches_type(Completion, completion, path=["response"])
54
55 @parametrize
56 def test_raw_response_create_overload_1(self, client: OpenAI) -> None:
57 response = client.completions.with_raw_response.create(
58 model="string",
59 prompt="This is a test.",
60 )
61
62 assert response.is_closed is True
63 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
64 completion = response.parse()
65 assert_matches_type(Completion, completion, path=["response"])
66
67 @parametrize
68 def test_streaming_response_create_overload_1(self, client: OpenAI) -> None:
69 with client.completions.with_streaming_response.create(
70 model="string",
71 prompt="This is a test.",
72 ) as response:
73 assert not response.is_closed
74 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
75
76 completion = response.parse()
77 assert_matches_type(Completion, completion, path=["response"])
78
79 assert cast(Any, response.is_closed) is True
80
81 @parametrize
82 def test_method_create_overload_2(self, client: OpenAI) -> None:
83 completion_stream = client.completions.create(
84 model="string",
85 prompt="This is a test.",
86 stream=True,
87 )
88 completion_stream.response.close()
89
90 @parametrize
91 def test_method_create_with_all_params_overload_2(self, client: OpenAI) -> None:
92 completion_stream = client.completions.create(
93 model="string",
94 prompt="This is a test.",
95 stream=True,
96 best_of=0,
97 echo=True,
98 frequency_penalty=-2,
99 logit_bias={"foo": 0},
100 logprobs=0,
101 max_tokens=16,
102 n=1,
103 presence_penalty=-2,
104 seed=-9223372036854776000,
105 stop="\n",
106 suffix="test.",
107 temperature=1,
108 top_p=1,
109 user="user-1234",
110 )
111 completion_stream.response.close()
112
113 @parametrize
114 def test_raw_response_create_overload_2(self, client: OpenAI) -> None:
115 response = client.completions.with_raw_response.create(
116 model="string",
117 prompt="This is a test.",
118 stream=True,
119 )
120
121 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
122 stream = response.parse()
123 stream.close()
124
125 @parametrize
126 def test_streaming_response_create_overload_2(self, client: OpenAI) -> None:
127 with client.completions.with_streaming_response.create(
128 model="string",
129 prompt="This is a test.",
130 stream=True,
131 ) as response:
132 assert not response.is_closed
133 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
134
135 stream = response.parse()
136 stream.close()
137
138 assert cast(Any, response.is_closed) is True
139
140
141class TestAsyncCompletions:
142 strict_client = AsyncOpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=True)
143 loose_client = AsyncOpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=False)
144 parametrize = pytest.mark.parametrize("client", [strict_client, loose_client], ids=["strict", "loose"])
145
146 @parametrize
147 async def test_method_create_overload_1(self, client: AsyncOpenAI) -> None:
148 completion = await client.completions.create(
149 model="string",
150 prompt="This is a test.",
151 )
152 assert_matches_type(Completion, completion, path=["response"])
153
154 @parametrize
155 async def test_method_create_with_all_params_overload_1(self, client: AsyncOpenAI) -> None:
156 completion = await client.completions.create(
157 model="string",
158 prompt="This is a test.",
159 best_of=0,
160 echo=True,
161 frequency_penalty=-2,
162 logit_bias={"foo": 0},
163 logprobs=0,
164 max_tokens=16,
165 n=1,
166 presence_penalty=-2,
167 seed=-9223372036854776000,
168 stop="\n",
169 stream=False,
170 suffix="test.",
171 temperature=1,
172 top_p=1,
173 user="user-1234",
174 )
175 assert_matches_type(Completion, completion, path=["response"])
176
177 @parametrize
178 async def test_raw_response_create_overload_1(self, client: AsyncOpenAI) -> None:
179 response = await client.completions.with_raw_response.create(
180 model="string",
181 prompt="This is a test.",
182 )
183
184 assert response.is_closed is True
185 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
186 completion = response.parse()
187 assert_matches_type(Completion, completion, path=["response"])
188
189 @parametrize
190 async def test_streaming_response_create_overload_1(self, client: AsyncOpenAI) -> None:
191 async with client.completions.with_streaming_response.create(
192 model="string",
193 prompt="This is a test.",
194 ) as response:
195 assert not response.is_closed
196 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
197
198 completion = await response.parse()
199 assert_matches_type(Completion, completion, path=["response"])
200
201 assert cast(Any, response.is_closed) is True
202
203 @parametrize
204 async def test_method_create_overload_2(self, client: AsyncOpenAI) -> None:
205 completion_stream = await client.completions.create(
206 model="string",
207 prompt="This is a test.",
208 stream=True,
209 )
210 await completion_stream.response.aclose()
211
212 @parametrize
213 async def test_method_create_with_all_params_overload_2(self, client: AsyncOpenAI) -> None:
214 completion_stream = await client.completions.create(
215 model="string",
216 prompt="This is a test.",
217 stream=True,
218 best_of=0,
219 echo=True,
220 frequency_penalty=-2,
221 logit_bias={"foo": 0},
222 logprobs=0,
223 max_tokens=16,
224 n=1,
225 presence_penalty=-2,
226 seed=-9223372036854776000,
227 stop="\n",
228 suffix="test.",
229 temperature=1,
230 top_p=1,
231 user="user-1234",
232 )
233 await completion_stream.response.aclose()
234
235 @parametrize
236 async def test_raw_response_create_overload_2(self, client: AsyncOpenAI) -> None:
237 response = await client.completions.with_raw_response.create(
238 model="string",
239 prompt="This is a test.",
240 stream=True,
241 )
242
243 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
244 stream = response.parse()
245 await stream.close()
246
247 @parametrize
248 async def test_streaming_response_create_overload_2(self, client: AsyncOpenAI) -> None:
249 async with client.completions.with_streaming_response.create(
250 model="string",
251 prompt="This is a test.",
252 stream=True,
253 ) as response:
254 assert not response.is_closed
255 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
256
257 stream = await response.parse()
258 await stream.close()
259
260 assert cast(Any, response.is_closed) is True
261