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.86.0

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

283lines · modecode

RawDownload
release: 1.83.0 (#2393)cca0970
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("async_client", [False, True], indirect=True, ids=["loose", "strict"])
155
156 @parametrize
157 async def test_method_run(self, async_client: AsyncOpenAI) -> None:
158 grader = await async_client.fine_tuning.alpha.graders.run(
159 grader={
160 "input": "input",
161 "name": "name",
162 "operation": "eq",
163 "reference": "reference",
164 "type": "string_check",
165 },
166 model_sample="model_sample",
167 )
168 assert_matches_type(GraderRunResponse, grader, path=["response"])
169
170 @parametrize
171 async def test_method_run_with_all_params(self, async_client: AsyncOpenAI) -> None:
172 grader = await async_client.fine_tuning.alpha.graders.run(
173 grader={
174 "input": "input",
175 "name": "name",
176 "operation": "eq",
177 "reference": "reference",
178 "type": "string_check",
179 },
180 model_sample="model_sample",
181 item={},
182 )
183 assert_matches_type(GraderRunResponse, grader, path=["response"])
184
185 @parametrize
186 async def test_raw_response_run(self, async_client: AsyncOpenAI) -> None:
187 response = await async_client.fine_tuning.alpha.graders.with_raw_response.run(
188 grader={
189 "input": "input",
190 "name": "name",
191 "operation": "eq",
192 "reference": "reference",
193 "type": "string_check",
194 },
195 model_sample="model_sample",
196 )
197
198 assert response.is_closed is True
199 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
200 grader = response.parse()
201 assert_matches_type(GraderRunResponse, grader, path=["response"])
202
203 @parametrize
204 async def test_streaming_response_run(self, async_client: AsyncOpenAI) -> None:
205 async with async_client.fine_tuning.alpha.graders.with_streaming_response.run(
206 grader={
207 "input": "input",
208 "name": "name",
209 "operation": "eq",
210 "reference": "reference",
211 "type": "string_check",
212 },
213 model_sample="model_sample",
214 ) as response:
215 assert not response.is_closed
216 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
217
218 grader = await response.parse()
219 assert_matches_type(GraderRunResponse, grader, path=["response"])
220
221 assert cast(Any, response.is_closed) is True
222
223 @parametrize
224 async def test_method_validate(self, async_client: AsyncOpenAI) -> None:
225 grader = await async_client.fine_tuning.alpha.graders.validate(
226 grader={
227 "input": "input",
228 "name": "name",
229 "operation": "eq",
230 "reference": "reference",
231 "type": "string_check",
232 },
233 )
234 assert_matches_type(GraderValidateResponse, grader, path=["response"])
235
236 @parametrize
237 async def test_method_validate_with_all_params(self, async_client: AsyncOpenAI) -> None:
238 grader = await async_client.fine_tuning.alpha.graders.validate(
239 grader={
240 "input": "input",
241 "name": "name",
242 "operation": "eq",
243 "reference": "reference",
244 "type": "string_check",
245 },
246 )
247 assert_matches_type(GraderValidateResponse, grader, path=["response"])
248
249 @parametrize
250 async def test_raw_response_validate(self, async_client: AsyncOpenAI) -> None:
251 response = await async_client.fine_tuning.alpha.graders.with_raw_response.validate(
252 grader={
253 "input": "input",
254 "name": "name",
255 "operation": "eq",
256 "reference": "reference",
257 "type": "string_check",
258 },
259 )
260
261 assert response.is_closed is True
262 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
263 grader = response.parse()
264 assert_matches_type(GraderValidateResponse, grader, path=["response"])
265
266 @parametrize
267 async def test_streaming_response_validate(self, async_client: AsyncOpenAI) -> None:
268 async with async_client.fine_tuning.alpha.graders.with_streaming_response.validate(
269 grader={
270 "input": "input",
271 "name": "name",
272 "operation": "eq",
273 "reference": "reference",
274 "type": "string_check",
275 },
276 ) as response:
277 assert not response.is_closed
278 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
279
280 grader = await response.parse()
281 assert_matches_type(GraderValidateResponse, grader, path=["response"])
282
283 assert cast(Any, response.is_closed) is True