main
1# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
2
3from __future__ import annotations
4
5import httpx
6
7from .... import _legacy_response
8from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
9from ...._utils import maybe_transform, async_maybe_transform
10from ...._compat import cached_property
11from ...._resource import SyncAPIResource, AsyncAPIResource
12from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
13from ...._base_client import make_request_options
14from ....types.fine_tuning.alpha import grader_run_params, grader_validate_params
15from ....types.fine_tuning.alpha.grader_run_response import GraderRunResponse
16from ....types.fine_tuning.alpha.grader_validate_response import GraderValidateResponse
17
18__all__ = ["Graders", "AsyncGraders"]
19
20
21class Graders(SyncAPIResource):
22 @cached_property
23 def with_raw_response(self) -> GradersWithRawResponse:
24 """
25 This property can be used as a prefix for any HTTP method call to return
26 the raw response object instead of the parsed content.
27
28 For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
29 """
30 return GradersWithRawResponse(self)
31
32 @cached_property
33 def with_streaming_response(self) -> GradersWithStreamingResponse:
34 """
35 An alternative to `.with_raw_response` that doesn't eagerly read the response body.
36
37 For more information, see https://www.github.com/openai/openai-python#with_streaming_response
38 """
39 return GradersWithStreamingResponse(self)
40
41 def run(
42 self,
43 *,
44 grader: grader_run_params.Grader,
45 model_sample: str,
46 item: object | Omit = omit,
47 # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
48 # The extra values given here take precedence over values defined on the client or passed to this method.
49 extra_headers: Headers | None = None,
50 extra_query: Query | None = None,
51 extra_body: Body | None = None,
52 timeout: float | httpx.Timeout | None | NotGiven = not_given,
53 ) -> GraderRunResponse:
54 """
55 Run a grader.
56
57 Args:
58 grader: The grader used for the fine-tuning job.
59
60 model_sample: The model sample to be evaluated. This value will be used to populate the
61 `sample` namespace. See
62 [the guide](https://platform.openai.com/docs/guides/graders) for more details.
63 The `output_json` variable will be populated if the model sample is a valid JSON
64 string.
65
66 item: The dataset item provided to the grader. This will be used to populate the
67 `item` namespace. See
68 [the guide](https://platform.openai.com/docs/guides/graders) for more details.
69
70 extra_headers: Send extra headers
71
72 extra_query: Add additional query parameters to the request
73
74 extra_body: Add additional JSON properties to the request
75
76 timeout: Override the client-level default timeout for this request, in seconds
77 """
78 return self._post(
79 "/fine_tuning/alpha/graders/run",
80 body=maybe_transform(
81 {
82 "grader": grader,
83 "model_sample": model_sample,
84 "item": item,
85 },
86 grader_run_params.GraderRunParams,
87 ),
88 options=make_request_options(
89 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
90 ),
91 cast_to=GraderRunResponse,
92 )
93
94 def validate(
95 self,
96 *,
97 grader: grader_validate_params.Grader,
98 # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
99 # The extra values given here take precedence over values defined on the client or passed to this method.
100 extra_headers: Headers | None = None,
101 extra_query: Query | None = None,
102 extra_body: Body | None = None,
103 timeout: float | httpx.Timeout | None | NotGiven = not_given,
104 ) -> GraderValidateResponse:
105 """
106 Validate a grader.
107
108 Args:
109 grader: The grader used for the fine-tuning job.
110
111 extra_headers: Send extra headers
112
113 extra_query: Add additional query parameters to the request
114
115 extra_body: Add additional JSON properties to the request
116
117 timeout: Override the client-level default timeout for this request, in seconds
118 """
119 return self._post(
120 "/fine_tuning/alpha/graders/validate",
121 body=maybe_transform({"grader": grader}, grader_validate_params.GraderValidateParams),
122 options=make_request_options(
123 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
124 ),
125 cast_to=GraderValidateResponse,
126 )
127
128
129class AsyncGraders(AsyncAPIResource):
130 @cached_property
131 def with_raw_response(self) -> AsyncGradersWithRawResponse:
132 """
133 This property can be used as a prefix for any HTTP method call to return
134 the raw response object instead of the parsed content.
135
136 For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
137 """
138 return AsyncGradersWithRawResponse(self)
139
140 @cached_property
141 def with_streaming_response(self) -> AsyncGradersWithStreamingResponse:
142 """
143 An alternative to `.with_raw_response` that doesn't eagerly read the response body.
144
145 For more information, see https://www.github.com/openai/openai-python#with_streaming_response
146 """
147 return AsyncGradersWithStreamingResponse(self)
148
149 async def run(
150 self,
151 *,
152 grader: grader_run_params.Grader,
153 model_sample: str,
154 item: object | Omit = omit,
155 # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
156 # The extra values given here take precedence over values defined on the client or passed to this method.
157 extra_headers: Headers | None = None,
158 extra_query: Query | None = None,
159 extra_body: Body | None = None,
160 timeout: float | httpx.Timeout | None | NotGiven = not_given,
161 ) -> GraderRunResponse:
162 """
163 Run a grader.
164
165 Args:
166 grader: The grader used for the fine-tuning job.
167
168 model_sample: The model sample to be evaluated. This value will be used to populate the
169 `sample` namespace. See
170 [the guide](https://platform.openai.com/docs/guides/graders) for more details.
171 The `output_json` variable will be populated if the model sample is a valid JSON
172 string.
173
174 item: The dataset item provided to the grader. This will be used to populate the
175 `item` namespace. See
176 [the guide](https://platform.openai.com/docs/guides/graders) for more details.
177
178 extra_headers: Send extra headers
179
180 extra_query: Add additional query parameters to the request
181
182 extra_body: Add additional JSON properties to the request
183
184 timeout: Override the client-level default timeout for this request, in seconds
185 """
186 return await self._post(
187 "/fine_tuning/alpha/graders/run",
188 body=await async_maybe_transform(
189 {
190 "grader": grader,
191 "model_sample": model_sample,
192 "item": item,
193 },
194 grader_run_params.GraderRunParams,
195 ),
196 options=make_request_options(
197 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
198 ),
199 cast_to=GraderRunResponse,
200 )
201
202 async def validate(
203 self,
204 *,
205 grader: grader_validate_params.Grader,
206 # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
207 # The extra values given here take precedence over values defined on the client or passed to this method.
208 extra_headers: Headers | None = None,
209 extra_query: Query | None = None,
210 extra_body: Body | None = None,
211 timeout: float | httpx.Timeout | None | NotGiven = not_given,
212 ) -> GraderValidateResponse:
213 """
214 Validate a grader.
215
216 Args:
217 grader: The grader used for the fine-tuning job.
218
219 extra_headers: Send extra headers
220
221 extra_query: Add additional query parameters to the request
222
223 extra_body: Add additional JSON properties to the request
224
225 timeout: Override the client-level default timeout for this request, in seconds
226 """
227 return await self._post(
228 "/fine_tuning/alpha/graders/validate",
229 body=await async_maybe_transform({"grader": grader}, grader_validate_params.GraderValidateParams),
230 options=make_request_options(
231 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
232 ),
233 cast_to=GraderValidateResponse,
234 )
235
236
237class GradersWithRawResponse:
238 def __init__(self, graders: Graders) -> None:
239 self._graders = graders
240
241 self.run = _legacy_response.to_raw_response_wrapper(
242 graders.run,
243 )
244 self.validate = _legacy_response.to_raw_response_wrapper(
245 graders.validate,
246 )
247
248
249class AsyncGradersWithRawResponse:
250 def __init__(self, graders: AsyncGraders) -> None:
251 self._graders = graders
252
253 self.run = _legacy_response.async_to_raw_response_wrapper(
254 graders.run,
255 )
256 self.validate = _legacy_response.async_to_raw_response_wrapper(
257 graders.validate,
258 )
259
260
261class GradersWithStreamingResponse:
262 def __init__(self, graders: Graders) -> None:
263 self._graders = graders
264
265 self.run = to_streamed_response_wrapper(
266 graders.run,
267 )
268 self.validate = to_streamed_response_wrapper(
269 graders.validate,
270 )
271
272
273class AsyncGradersWithStreamingResponse:
274 def __init__(self, graders: AsyncGraders) -> None:
275 self._graders = graders
276
277 self.run = async_to_streamed_response_wrapper(
278 graders.run,
279 )
280 self.validate = async_to_streamed_response_wrapper(
281 graders.validate,
282 )