GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

openai/openai-python

Public

mirrored fromhttps://github.com/openai/openai-pythonAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
codex/remove-scheduled-release-run

Branches

Tags

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

Clone

HTTPS

Download ZIP

openai-python/tests/api_resources/fine_tuning/alpha

tests/api_resources/fine_tuning/alpha/test_graders.py

285lines · 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.fine_tuning.alpha import (
13 GraderRunResponse,
14 GraderValidateResponse,
15)
16
17base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
18
19
20class TestGraders:
21 parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
22
23 @parametrize
24 def test_method_run(self, client: OpenAI) -> None:
25 grader = client.fine_tuning.alpha.graders.run(
26 grader={
27 "input": "input",
28 "name": "name",
29 "operation": "eq",
30 "reference": "reference",
31 "type": "string_check",
32 },
33 model_sample="model_sample",
34 )
35 assert_matches_type(GraderRunResponse, grader, path=["response"])
36
37 @parametrize
38 def test_method_run_with_all_params(self, client: OpenAI) -> None:
39 grader = client.fine_tuning.alpha.graders.run(
40 grader={
41 "input": "input",
42 "name": "name",
43 "operation": "eq",
44 "reference": "reference",
45 "type": "string_check",
46 },
47 model_sample="model_sample",
48 item={},
49 )
50 assert_matches_type(GraderRunResponse, grader, path=["response"])
51
52 @parametrize
53 def test_raw_response_run(self, client: OpenAI) -> None:
54 response = client.fine_tuning.alpha.graders.with_raw_response.run(
55 grader={
56 "input": "input",
57 "name": "name",
58 "operation": "eq",
59 "reference": "reference",
60 "type": "string_check",
61 },
62 model_sample="model_sample",
63 )
64
65 assert response.is_closed is True
66 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
67 grader = response.parse()
68 assert_matches_type(GraderRunResponse, grader, path=["response"])
69
70 @parametrize
71 def test_streaming_response_run(self, client: OpenAI) -> None:
72 with client.fine_tuning.alpha.graders.with_streaming_response.run(
73 grader={
74 "input": "input",
75 "name": "name",
76 "operation": "eq",
77 "reference": "reference",
78 "type": "string_check",
79 },
80 model_sample="model_sample",
81 ) as response:
82 assert not response.is_closed
83 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
84
85 grader = response.parse()
86 assert_matches_type(GraderRunResponse, grader, path=["response"])
87
88 assert cast(Any, response.is_closed) is True
89
90 @parametrize
91 def test_method_validate(self, client: OpenAI) -> None:
92 grader = client.fine_tuning.alpha.graders.validate(
93 grader={
94 "input": "input",
95 "name": "name",
96 "operation": "eq",
97 "reference": "reference",
98 "type": "string_check",
99 },
100 )
101 assert_matches_type(GraderValidateResponse, grader, path=["response"])
102
103 @parametrize
104 def test_method_validate_with_all_params(self, client: OpenAI) -> None:
105 grader = client.fine_tuning.alpha.graders.validate(
106 grader={
107 "input": "input",
108 "name": "name",
109 "operation": "eq",
110 "reference": "reference",
111 "type": "string_check",
112 },
113 )
114 assert_matches_type(GraderValidateResponse, grader, path=["response"])
115
116 @parametrize
117 def test_raw_response_validate(self, client: OpenAI) -> None:
118 response = client.fine_tuning.alpha.graders.with_raw_response.validate(
119 grader={
120 "input": "input",
121 "name": "name",
122 "operation": "eq",
123 "reference": "reference",
124 "type": "string_check",
125 },
126 )
127
128 assert response.is_closed is True
129 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
130 grader = response.parse()
131 assert_matches_type(GraderValidateResponse, grader, path=["response"])
132
133 @parametrize
134 def test_streaming_response_validate(self, client: OpenAI) -> None:
135 with client.fine_tuning.alpha.graders.with_streaming_response.validate(
136 grader={
137 "input": "input",
138 "name": "name",
139 "operation": "eq",
140 "reference": "reference",
141 "type": "string_check",
142 },
143 ) as response:
144 assert not response.is_closed
145 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
146
147 grader = response.parse()
148 assert_matches_type(GraderValidateResponse, grader, path=["response"])
149
150 assert cast(Any, response.is_closed) is True
151
152
153class TestAsyncGraders:
154 parametrize = pytest.mark.parametrize(
155 "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
156 )
157
158 @parametrize
159 async def test_method_run(self, async_client: AsyncOpenAI) -> None:
160 grader = await async_client.fine_tuning.alpha.graders.run(
161 grader={
162 "input": "input",
163 "name": "name",
164 "operation": "eq",
165 "reference": "reference",
166 "type": "string_check",
167 },
168 model_sample="model_sample",
169 )
170 assert_matches_type(GraderRunResponse, grader, path=["response"])
171
172 @parametrize
173 async def test_method_run_with_all_params(self, async_client: AsyncOpenAI) -> None:
174 grader = await async_client.fine_tuning.alpha.graders.run(
175 grader={
176 "input": "input",
177 "name": "name",
178 "operation": "eq",
179 "reference": "reference",
180 "type": "string_check",
181 },
182 model_sample="model_sample",
183 item={},
184 )
185 assert_matches_type(GraderRunResponse, grader, path=["response"])
186
187 @parametrize
188 async def test_raw_response_run(self, async_client: AsyncOpenAI) -> None:
189 response = await async_client.fine_tuning.alpha.graders.with_raw_response.run(
190 grader={
191 "input": "input",
192 "name": "name",
193 "operation": "eq",
194 "reference": "reference",
195 "type": "string_check",
196 },
197 model_sample="model_sample",
198 )
199
200 assert response.is_closed is True
201 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
202 grader = response.parse()
203 assert_matches_type(GraderRunResponse, grader, path=["response"])
204
205 @parametrize
206 async def test_streaming_response_run(self, async_client: AsyncOpenAI) -> None:
207 async with async_client.fine_tuning.alpha.graders.with_streaming_response.run(
208 grader={
209 "input": "input",
210 "name": "name",
211 "operation": "eq",
212 "reference": "reference",
213 "type": "string_check",
214 },
215 model_sample="model_sample",
216 ) as response:
217 assert not response.is_closed
218 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
219
220 grader = await response.parse()
221 assert_matches_type(GraderRunResponse, grader, path=["response"])
222
223 assert cast(Any, response.is_closed) is True
224
225 @parametrize
226 async def test_method_validate(self, async_client: AsyncOpenAI) -> None:
227 grader = await async_client.fine_tuning.alpha.graders.validate(
228 grader={
229 "input": "input",
230 "name": "name",
231 "operation": "eq",
232 "reference": "reference",
233 "type": "string_check",
234 },
235 )
236 assert_matches_type(GraderValidateResponse, grader, path=["response"])
237
238 @parametrize
239 async def test_method_validate_with_all_params(self, async_client: AsyncOpenAI) -> None:
240 grader = await async_client.fine_tuning.alpha.graders.validate(
241 grader={
242 "input": "input",
243 "name": "name",
244 "operation": "eq",
245 "reference": "reference",
246 "type": "string_check",
247 },
248 )
249 assert_matches_type(GraderValidateResponse, grader, path=["response"])
250
251 @parametrize
252 async def test_raw_response_validate(self, async_client: AsyncOpenAI) -> None:
253 response = await async_client.fine_tuning.alpha.graders.with_raw_response.validate(
254 grader={
255 "input": "input",
256 "name": "name",
257 "operation": "eq",
258 "reference": "reference",
259 "type": "string_check",
260 },
261 )
262
263 assert response.is_closed is True
264 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
265 grader = response.parse()
266 assert_matches_type(GraderValidateResponse, grader, path=["response"])
267
268 @parametrize
269 async def test_streaming_response_validate(self, async_client: AsyncOpenAI) -> None:
270 async with async_client.fine_tuning.alpha.graders.with_streaming_response.validate(
271 grader={
272 "input": "input",
273 "name": "name",
274 "operation": "eq",
275 "reference": "reference",
276 "type": "string_check",
277 },
278 ) as response:
279 assert not response.is_closed
280 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
281
282 grader = await response.parse()
283 assert_matches_type(GraderValidateResponse, grader, path=["response"])
284
285 assert cast(Any, response.is_closed) is True
286