main
1# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
2
3from __future__ import annotations
4
5from typing_extensions import Literal
6
7import httpx
8
9from .... import _legacy_response
10from ...._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
11from ...._utils import maybe_transform, async_maybe_transform
12from ...._compat import cached_property
13from ...._resource import SyncAPIResource, AsyncAPIResource
14from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
15from ....pagination import SyncPage, AsyncPage
16from ...._base_client import AsyncPaginator, make_request_options
17from ....types.fine_tuning.checkpoints import permission_create_params, permission_retrieve_params
18from ....types.fine_tuning.checkpoints.permission_create_response import PermissionCreateResponse
19from ....types.fine_tuning.checkpoints.permission_delete_response import PermissionDeleteResponse
20from ....types.fine_tuning.checkpoints.permission_retrieve_response import PermissionRetrieveResponse
21
22__all__ = ["Permissions", "AsyncPermissions"]
23
24
25class Permissions(SyncAPIResource):
26 @cached_property
27 def with_raw_response(self) -> PermissionsWithRawResponse:
28 """
29 This property can be used as a prefix for any HTTP method call to return
30 the raw response object instead of the parsed content.
31
32 For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
33 """
34 return PermissionsWithRawResponse(self)
35
36 @cached_property
37 def with_streaming_response(self) -> PermissionsWithStreamingResponse:
38 """
39 An alternative to `.with_raw_response` that doesn't eagerly read the response body.
40
41 For more information, see https://www.github.com/openai/openai-python#with_streaming_response
42 """
43 return PermissionsWithStreamingResponse(self)
44
45 def create(
46 self,
47 fine_tuned_model_checkpoint: str,
48 *,
49 project_ids: SequenceNotStr[str],
50 # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
51 # The extra values given here take precedence over values defined on the client or passed to this method.
52 extra_headers: Headers | None = None,
53 extra_query: Query | None = None,
54 extra_body: Body | None = None,
55 timeout: float | httpx.Timeout | None | NotGiven = not_given,
56 ) -> SyncPage[PermissionCreateResponse]:
57 """
58 **NOTE:** Calling this endpoint requires an [admin API key](../admin-api-keys).
59
60 This enables organization owners to share fine-tuned models with other projects
61 in their organization.
62
63 Args:
64 project_ids: The project identifiers to grant access to.
65
66 extra_headers: Send extra headers
67
68 extra_query: Add additional query parameters to the request
69
70 extra_body: Add additional JSON properties to the request
71
72 timeout: Override the client-level default timeout for this request, in seconds
73 """
74 if not fine_tuned_model_checkpoint:
75 raise ValueError(
76 f"Expected a non-empty value for `fine_tuned_model_checkpoint` but received {fine_tuned_model_checkpoint!r}"
77 )
78 return self._get_api_list(
79 f"/fine_tuning/checkpoints/{fine_tuned_model_checkpoint}/permissions",
80 page=SyncPage[PermissionCreateResponse],
81 body=maybe_transform({"project_ids": project_ids}, permission_create_params.PermissionCreateParams),
82 options=make_request_options(
83 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
84 ),
85 model=PermissionCreateResponse,
86 method="post",
87 )
88
89 def retrieve(
90 self,
91 fine_tuned_model_checkpoint: str,
92 *,
93 after: str | Omit = omit,
94 limit: int | Omit = omit,
95 order: Literal["ascending", "descending"] | Omit = omit,
96 project_id: str | Omit = omit,
97 # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
98 # The extra values given here take precedence over values defined on the client or passed to this method.
99 extra_headers: Headers | None = None,
100 extra_query: Query | None = None,
101 extra_body: Body | None = None,
102 timeout: float | httpx.Timeout | None | NotGiven = not_given,
103 ) -> PermissionRetrieveResponse:
104 """
105 **NOTE:** This endpoint requires an [admin API key](../admin-api-keys).
106
107 Organization owners can use this endpoint to view all permissions for a
108 fine-tuned model checkpoint.
109
110 Args:
111 after: Identifier for the last permission ID from the previous pagination request.
112
113 limit: Number of permissions to retrieve.
114
115 order: The order in which to retrieve permissions.
116
117 project_id: The ID of the project to get permissions for.
118
119 extra_headers: Send extra headers
120
121 extra_query: Add additional query parameters to the request
122
123 extra_body: Add additional JSON properties to the request
124
125 timeout: Override the client-level default timeout for this request, in seconds
126 """
127 if not fine_tuned_model_checkpoint:
128 raise ValueError(
129 f"Expected a non-empty value for `fine_tuned_model_checkpoint` but received {fine_tuned_model_checkpoint!r}"
130 )
131 return self._get(
132 f"/fine_tuning/checkpoints/{fine_tuned_model_checkpoint}/permissions",
133 options=make_request_options(
134 extra_headers=extra_headers,
135 extra_query=extra_query,
136 extra_body=extra_body,
137 timeout=timeout,
138 query=maybe_transform(
139 {
140 "after": after,
141 "limit": limit,
142 "order": order,
143 "project_id": project_id,
144 },
145 permission_retrieve_params.PermissionRetrieveParams,
146 ),
147 ),
148 cast_to=PermissionRetrieveResponse,
149 )
150
151 def delete(
152 self,
153 permission_id: str,
154 *,
155 fine_tuned_model_checkpoint: str,
156 # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
157 # The extra values given here take precedence over values defined on the client or passed to this method.
158 extra_headers: Headers | None = None,
159 extra_query: Query | None = None,
160 extra_body: Body | None = None,
161 timeout: float | httpx.Timeout | None | NotGiven = not_given,
162 ) -> PermissionDeleteResponse:
163 """
164 **NOTE:** This endpoint requires an [admin API key](../admin-api-keys).
165
166 Organization owners can use this endpoint to delete a permission for a
167 fine-tuned model checkpoint.
168
169 Args:
170 extra_headers: Send extra headers
171
172 extra_query: Add additional query parameters to the request
173
174 extra_body: Add additional JSON properties to the request
175
176 timeout: Override the client-level default timeout for this request, in seconds
177 """
178 if not fine_tuned_model_checkpoint:
179 raise ValueError(
180 f"Expected a non-empty value for `fine_tuned_model_checkpoint` but received {fine_tuned_model_checkpoint!r}"
181 )
182 if not permission_id:
183 raise ValueError(f"Expected a non-empty value for `permission_id` but received {permission_id!r}")
184 return self._delete(
185 f"/fine_tuning/checkpoints/{fine_tuned_model_checkpoint}/permissions/{permission_id}",
186 options=make_request_options(
187 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
188 ),
189 cast_to=PermissionDeleteResponse,
190 )
191
192
193class AsyncPermissions(AsyncAPIResource):
194 @cached_property
195 def with_raw_response(self) -> AsyncPermissionsWithRawResponse:
196 """
197 This property can be used as a prefix for any HTTP method call to return
198 the raw response object instead of the parsed content.
199
200 For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
201 """
202 return AsyncPermissionsWithRawResponse(self)
203
204 @cached_property
205 def with_streaming_response(self) -> AsyncPermissionsWithStreamingResponse:
206 """
207 An alternative to `.with_raw_response` that doesn't eagerly read the response body.
208
209 For more information, see https://www.github.com/openai/openai-python#with_streaming_response
210 """
211 return AsyncPermissionsWithStreamingResponse(self)
212
213 def create(
214 self,
215 fine_tuned_model_checkpoint: str,
216 *,
217 project_ids: SequenceNotStr[str],
218 # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
219 # The extra values given here take precedence over values defined on the client or passed to this method.
220 extra_headers: Headers | None = None,
221 extra_query: Query | None = None,
222 extra_body: Body | None = None,
223 timeout: float | httpx.Timeout | None | NotGiven = not_given,
224 ) -> AsyncPaginator[PermissionCreateResponse, AsyncPage[PermissionCreateResponse]]:
225 """
226 **NOTE:** Calling this endpoint requires an [admin API key](../admin-api-keys).
227
228 This enables organization owners to share fine-tuned models with other projects
229 in their organization.
230
231 Args:
232 project_ids: The project identifiers to grant access to.
233
234 extra_headers: Send extra headers
235
236 extra_query: Add additional query parameters to the request
237
238 extra_body: Add additional JSON properties to the request
239
240 timeout: Override the client-level default timeout for this request, in seconds
241 """
242 if not fine_tuned_model_checkpoint:
243 raise ValueError(
244 f"Expected a non-empty value for `fine_tuned_model_checkpoint` but received {fine_tuned_model_checkpoint!r}"
245 )
246 return self._get_api_list(
247 f"/fine_tuning/checkpoints/{fine_tuned_model_checkpoint}/permissions",
248 page=AsyncPage[PermissionCreateResponse],
249 body=maybe_transform({"project_ids": project_ids}, permission_create_params.PermissionCreateParams),
250 options=make_request_options(
251 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
252 ),
253 model=PermissionCreateResponse,
254 method="post",
255 )
256
257 async def retrieve(
258 self,
259 fine_tuned_model_checkpoint: str,
260 *,
261 after: str | Omit = omit,
262 limit: int | Omit = omit,
263 order: Literal["ascending", "descending"] | Omit = omit,
264 project_id: str | Omit = omit,
265 # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
266 # The extra values given here take precedence over values defined on the client or passed to this method.
267 extra_headers: Headers | None = None,
268 extra_query: Query | None = None,
269 extra_body: Body | None = None,
270 timeout: float | httpx.Timeout | None | NotGiven = not_given,
271 ) -> PermissionRetrieveResponse:
272 """
273 **NOTE:** This endpoint requires an [admin API key](../admin-api-keys).
274
275 Organization owners can use this endpoint to view all permissions for a
276 fine-tuned model checkpoint.
277
278 Args:
279 after: Identifier for the last permission ID from the previous pagination request.
280
281 limit: Number of permissions to retrieve.
282
283 order: The order in which to retrieve permissions.
284
285 project_id: The ID of the project to get permissions for.
286
287 extra_headers: Send extra headers
288
289 extra_query: Add additional query parameters to the request
290
291 extra_body: Add additional JSON properties to the request
292
293 timeout: Override the client-level default timeout for this request, in seconds
294 """
295 if not fine_tuned_model_checkpoint:
296 raise ValueError(
297 f"Expected a non-empty value for `fine_tuned_model_checkpoint` but received {fine_tuned_model_checkpoint!r}"
298 )
299 return await self._get(
300 f"/fine_tuning/checkpoints/{fine_tuned_model_checkpoint}/permissions",
301 options=make_request_options(
302 extra_headers=extra_headers,
303 extra_query=extra_query,
304 extra_body=extra_body,
305 timeout=timeout,
306 query=await async_maybe_transform(
307 {
308 "after": after,
309 "limit": limit,
310 "order": order,
311 "project_id": project_id,
312 },
313 permission_retrieve_params.PermissionRetrieveParams,
314 ),
315 ),
316 cast_to=PermissionRetrieveResponse,
317 )
318
319 async def delete(
320 self,
321 permission_id: str,
322 *,
323 fine_tuned_model_checkpoint: str,
324 # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
325 # The extra values given here take precedence over values defined on the client or passed to this method.
326 extra_headers: Headers | None = None,
327 extra_query: Query | None = None,
328 extra_body: Body | None = None,
329 timeout: float | httpx.Timeout | None | NotGiven = not_given,
330 ) -> PermissionDeleteResponse:
331 """
332 **NOTE:** This endpoint requires an [admin API key](../admin-api-keys).
333
334 Organization owners can use this endpoint to delete a permission for a
335 fine-tuned model checkpoint.
336
337 Args:
338 extra_headers: Send extra headers
339
340 extra_query: Add additional query parameters to the request
341
342 extra_body: Add additional JSON properties to the request
343
344 timeout: Override the client-level default timeout for this request, in seconds
345 """
346 if not fine_tuned_model_checkpoint:
347 raise ValueError(
348 f"Expected a non-empty value for `fine_tuned_model_checkpoint` but received {fine_tuned_model_checkpoint!r}"
349 )
350 if not permission_id:
351 raise ValueError(f"Expected a non-empty value for `permission_id` but received {permission_id!r}")
352 return await self._delete(
353 f"/fine_tuning/checkpoints/{fine_tuned_model_checkpoint}/permissions/{permission_id}",
354 options=make_request_options(
355 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
356 ),
357 cast_to=PermissionDeleteResponse,
358 )
359
360
361class PermissionsWithRawResponse:
362 def __init__(self, permissions: Permissions) -> None:
363 self._permissions = permissions
364
365 self.create = _legacy_response.to_raw_response_wrapper(
366 permissions.create,
367 )
368 self.retrieve = _legacy_response.to_raw_response_wrapper(
369 permissions.retrieve,
370 )
371 self.delete = _legacy_response.to_raw_response_wrapper(
372 permissions.delete,
373 )
374
375
376class AsyncPermissionsWithRawResponse:
377 def __init__(self, permissions: AsyncPermissions) -> None:
378 self._permissions = permissions
379
380 self.create = _legacy_response.async_to_raw_response_wrapper(
381 permissions.create,
382 )
383 self.retrieve = _legacy_response.async_to_raw_response_wrapper(
384 permissions.retrieve,
385 )
386 self.delete = _legacy_response.async_to_raw_response_wrapper(
387 permissions.delete,
388 )
389
390
391class PermissionsWithStreamingResponse:
392 def __init__(self, permissions: Permissions) -> None:
393 self._permissions = permissions
394
395 self.create = to_streamed_response_wrapper(
396 permissions.create,
397 )
398 self.retrieve = to_streamed_response_wrapper(
399 permissions.retrieve,
400 )
401 self.delete = to_streamed_response_wrapper(
402 permissions.delete,
403 )
404
405
406class AsyncPermissionsWithStreamingResponse:
407 def __init__(self, permissions: AsyncPermissions) -> None:
408 self._permissions = permissions
409
410 self.create = async_to_streamed_response_wrapper(
411 permissions.create,
412 )
413 self.retrieve = async_to_streamed_response_wrapper(
414 permissions.retrieve,
415 )
416 self.delete = async_to_streamed_response_wrapper(
417 permissions.delete,
418 )