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
robert/fix-streaming-parsing

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

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