nufi-python 1.0.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- nufi/__init__.py +52 -0
- nufi/auth.py +364 -0
- nufi/cli/__init__.py +0 -0
- nufi/cli/commands/__init__.py +1 -0
- nufi/cli/commands/auth.py +113 -0
- nufi/cli/commands/common.py +198 -0
- nufi/cli/commands/compiles.py +507 -0
- nufi/cli/commands/custom_evaluation_templates.py +206 -0
- nufi/cli/commands/datasets.py +697 -0
- nufi/cli/commands/evaluations.py +854 -0
- nufi/cli/commands/leaderboards.py +763 -0
- nufi/cli/commands/models.py +1347 -0
- nufi/cli/commands/monitoring.py +350 -0
- nufi/cli/commands/profile.py +123 -0
- nufi/cli/commands/projects.py +308 -0
- nufi/cli/commands/servings.py +306 -0
- nufi/cli/main.py +66 -0
- nufi/client.py +103 -0
- nufi/config.py +281 -0
- nufi/evaluator.py +559 -0
- nufi/exceptions.py +58 -0
- nufi/http_utils.py +51 -0
- nufi/models/__init__.py +185 -0
- nufi/models/compiles.py +79 -0
- nufi/models/custom_evaluation_templates.py +111 -0
- nufi/models/datasets.py +94 -0
- nufi/models/evaluations.py +253 -0
- nufi/models/leaderboards.py +178 -0
- nufi/models/monitoring.py +179 -0
- nufi/models/pagination.py +33 -0
- nufi/models/projects.py +32 -0
- nufi/models/registry.py +138 -0
- nufi/models/servings.py +27 -0
- nufi/py.typed +1 -0
- nufi/resources/__init__.py +34 -0
- nufi/resources/base.py +190 -0
- nufi/resources/compiles.py +193 -0
- nufi/resources/custom_evaluation_templates.py +126 -0
- nufi/resources/datasets.py +786 -0
- nufi/resources/evaluations.py +428 -0
- nufi/resources/leaderboards.py +413 -0
- nufi/resources/models.py +726 -0
- nufi/resources/monitoring.py +82 -0
- nufi/resources/projects.py +114 -0
- nufi/resources/servings.py +80 -0
- nufi/transport.py +248 -0
- nufi_python-1.0.0.dist-info/METADATA +228 -0
- nufi_python-1.0.0.dist-info/RECORD +52 -0
- nufi_python-1.0.0.dist-info/WHEEL +5 -0
- nufi_python-1.0.0.dist-info/entry_points.txt +2 -0
- nufi_python-1.0.0.dist-info/licenses/LICENSE +21 -0
- nufi_python-1.0.0.dist-info/top_level.txt +1 -0
nufi/resources/models.py
ADDED
|
@@ -0,0 +1,726 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
import time
|
|
4
|
+
from collections.abc import Iterator
|
|
5
|
+
from typing import Any
|
|
6
|
+
|
|
7
|
+
from nufi.exceptions import NotFoundError
|
|
8
|
+
from nufi.models import (
|
|
9
|
+
ArtifactValidation,
|
|
10
|
+
HuggingFaceMapping,
|
|
11
|
+
ModelArtifact,
|
|
12
|
+
ModelArtifactCreate,
|
|
13
|
+
ModelDetail,
|
|
14
|
+
ModelImport,
|
|
15
|
+
ModelVersion,
|
|
16
|
+
Page,
|
|
17
|
+
RegisteredModel,
|
|
18
|
+
)
|
|
19
|
+
from nufi.resources.base import BaseResource, ProjectRef, escape_path, response_json
|
|
20
|
+
|
|
21
|
+
_IMPORT_TERMINAL_STATES = frozenset({"completed", "failed"})
|
|
22
|
+
|
|
23
|
+
|
|
24
|
+
def _without_none(payload: dict[str, Any]) -> dict[str, Any]:
|
|
25
|
+
return {key: value for key, value in payload.items() if value is not None}
|
|
26
|
+
|
|
27
|
+
|
|
28
|
+
def _model_artifact_payload(
|
|
29
|
+
artifact: ModelArtifactCreate | dict[str, Any],
|
|
30
|
+
) -> dict[str, Any]:
|
|
31
|
+
return ModelArtifactCreate.model_validate(artifact).model_dump(
|
|
32
|
+
by_alias=True, exclude_none=True
|
|
33
|
+
)
|
|
34
|
+
|
|
35
|
+
|
|
36
|
+
def _wait_values(timeout: float, interval: float) -> tuple[float, float]:
|
|
37
|
+
if timeout <= 0:
|
|
38
|
+
raise ValueError("timeout must be greater than 0")
|
|
39
|
+
if interval <= 0:
|
|
40
|
+
raise ValueError("interval must be greater than 0")
|
|
41
|
+
return time.monotonic() + timeout, interval
|
|
42
|
+
|
|
43
|
+
|
|
44
|
+
def _response_list(response: Any) -> list[Any]:
|
|
45
|
+
payload = response.json()
|
|
46
|
+
if not isinstance(payload, list):
|
|
47
|
+
raise ValueError("Expected JSON array response from NuFi API.")
|
|
48
|
+
return payload
|
|
49
|
+
|
|
50
|
+
|
|
51
|
+
class ModelVersionsResource(BaseResource):
|
|
52
|
+
"""Model version operations."""
|
|
53
|
+
|
|
54
|
+
def _path(self, project_id: int, model: str) -> str:
|
|
55
|
+
return f"/api/v1/projects/{project_id}/models/{escape_path(model)}/versions"
|
|
56
|
+
|
|
57
|
+
def list(
|
|
58
|
+
self,
|
|
59
|
+
model: str,
|
|
60
|
+
*,
|
|
61
|
+
project: ProjectRef | None = None,
|
|
62
|
+
page: int | None = None,
|
|
63
|
+
limit: int | None = None,
|
|
64
|
+
) -> list[ModelVersion]:
|
|
65
|
+
"""Return one server page of model versions."""
|
|
66
|
+
project_id = self._resolve_project_id(project)
|
|
67
|
+
params, _, _ = self._pagination_params(page, limit)
|
|
68
|
+
payload = response_json(
|
|
69
|
+
self._transport.get(self._path(project_id, model), params=params)
|
|
70
|
+
)
|
|
71
|
+
return [
|
|
72
|
+
ModelVersion.model_validate(version)
|
|
73
|
+
for version in payload.get("versions", [])
|
|
74
|
+
if isinstance(version, dict)
|
|
75
|
+
]
|
|
76
|
+
|
|
77
|
+
def list_page(
|
|
78
|
+
self,
|
|
79
|
+
model: str,
|
|
80
|
+
*,
|
|
81
|
+
project: ProjectRef | None = None,
|
|
82
|
+
page: int | None = None,
|
|
83
|
+
limit: int | None = None,
|
|
84
|
+
) -> Page[ModelVersion]:
|
|
85
|
+
"""Return one version page with server pagination metadata."""
|
|
86
|
+
project_id = self._resolve_project_id(project)
|
|
87
|
+
params, resolved_page, resolved_limit = self._pagination_params(
|
|
88
|
+
page, limit, default_page=1, default_limit=10
|
|
89
|
+
)
|
|
90
|
+
payload = response_json(
|
|
91
|
+
self._transport.get(self._path(project_id, model), params=params)
|
|
92
|
+
)
|
|
93
|
+
return self._page(
|
|
94
|
+
payload,
|
|
95
|
+
ModelVersion,
|
|
96
|
+
item_keys=("versions",),
|
|
97
|
+
page=resolved_page,
|
|
98
|
+
limit=resolved_limit,
|
|
99
|
+
)
|
|
100
|
+
|
|
101
|
+
def iter_all(
|
|
102
|
+
self,
|
|
103
|
+
model: str,
|
|
104
|
+
*,
|
|
105
|
+
project: ProjectRef | None = None,
|
|
106
|
+
limit: int = 100,
|
|
107
|
+
) -> Iterator[ModelVersion]:
|
|
108
|
+
"""Iterate all versions in server order."""
|
|
109
|
+
return self._iter_all(
|
|
110
|
+
lambda page, page_limit: self.list_page(
|
|
111
|
+
model, project=project, page=page, limit=page_limit
|
|
112
|
+
),
|
|
113
|
+
limit=limit,
|
|
114
|
+
)
|
|
115
|
+
|
|
116
|
+
def get(
|
|
117
|
+
self,
|
|
118
|
+
model: str,
|
|
119
|
+
version: str,
|
|
120
|
+
*,
|
|
121
|
+
project: ProjectRef | None = None,
|
|
122
|
+
) -> ModelVersion:
|
|
123
|
+
"""Get a model version by its natural model and version names."""
|
|
124
|
+
project_id = self._resolve_project_id(project)
|
|
125
|
+
response = self._transport.get(
|
|
126
|
+
f"{self._path(project_id, model)}/{escape_path(version)}"
|
|
127
|
+
)
|
|
128
|
+
return ModelVersion.model_validate(response_json(response))
|
|
129
|
+
|
|
130
|
+
def create(
|
|
131
|
+
self,
|
|
132
|
+
model: str,
|
|
133
|
+
version: str,
|
|
134
|
+
*,
|
|
135
|
+
artifact: ModelArtifactCreate | dict[str, Any],
|
|
136
|
+
project: ProjectRef | None = None,
|
|
137
|
+
description: str | None = None,
|
|
138
|
+
author: str | None = None,
|
|
139
|
+
metadata: dict[str, Any] | None = None,
|
|
140
|
+
source_type: str | None = None,
|
|
141
|
+
source_ref: str | None = None,
|
|
142
|
+
) -> ModelVersion:
|
|
143
|
+
"""Create a model version with its required base artifact."""
|
|
144
|
+
project_id = self._resolve_project_id(project)
|
|
145
|
+
payload = _without_none(
|
|
146
|
+
{
|
|
147
|
+
"version": version,
|
|
148
|
+
"description": description,
|
|
149
|
+
"author": author,
|
|
150
|
+
"metadata": metadata,
|
|
151
|
+
"sourceType": source_type,
|
|
152
|
+
"sourceRef": source_ref,
|
|
153
|
+
"artifact": _model_artifact_payload(artifact),
|
|
154
|
+
}
|
|
155
|
+
)
|
|
156
|
+
response = self._transport.post(self._path(project_id, model), json=payload)
|
|
157
|
+
return ModelVersion.model_validate(response_json(response))
|
|
158
|
+
|
|
159
|
+
def update(
|
|
160
|
+
self,
|
|
161
|
+
model: str,
|
|
162
|
+
version: str,
|
|
163
|
+
*,
|
|
164
|
+
project: ProjectRef | None = None,
|
|
165
|
+
description: str | None = None,
|
|
166
|
+
metadata: dict[str, Any] | None = None,
|
|
167
|
+
) -> ModelVersion:
|
|
168
|
+
"""Update mutable model version fields."""
|
|
169
|
+
project_id = self._resolve_project_id(project)
|
|
170
|
+
response = self._transport.patch(
|
|
171
|
+
f"{self._path(project_id, model)}/{escape_path(version)}",
|
|
172
|
+
json={"description": description, "metadata": metadata},
|
|
173
|
+
)
|
|
174
|
+
return ModelVersion.model_validate(response_json(response))
|
|
175
|
+
|
|
176
|
+
def delete(
|
|
177
|
+
self,
|
|
178
|
+
model: str,
|
|
179
|
+
version: str,
|
|
180
|
+
*,
|
|
181
|
+
project: ProjectRef | None = None,
|
|
182
|
+
) -> None:
|
|
183
|
+
"""Delete a model version."""
|
|
184
|
+
project_id = self._resolve_project_id(project)
|
|
185
|
+
self._transport.delete(
|
|
186
|
+
f"{self._path(project_id, model)}/{escape_path(version)}"
|
|
187
|
+
)
|
|
188
|
+
|
|
189
|
+
|
|
190
|
+
class ModelArtifactsResource(BaseResource):
|
|
191
|
+
"""Model artifact operations."""
|
|
192
|
+
|
|
193
|
+
def _path(self, project_id: int, model: str, version: str) -> str:
|
|
194
|
+
return (
|
|
195
|
+
f"/api/v1/projects/{project_id}/models/{escape_path(model)}"
|
|
196
|
+
f"/versions/{escape_path(version)}/artifacts"
|
|
197
|
+
)
|
|
198
|
+
|
|
199
|
+
def list(
|
|
200
|
+
self,
|
|
201
|
+
model: str,
|
|
202
|
+
version: str,
|
|
203
|
+
*,
|
|
204
|
+
project: ProjectRef | None = None,
|
|
205
|
+
include_trial_artifacts: bool = False,
|
|
206
|
+
) -> list[ModelArtifact]:
|
|
207
|
+
"""Return the server's artifact collection."""
|
|
208
|
+
project_id = self._resolve_project_id(project)
|
|
209
|
+
params = (
|
|
210
|
+
{"include_trial_artifacts": "true"} if include_trial_artifacts else None
|
|
211
|
+
)
|
|
212
|
+
response = self._transport.get(
|
|
213
|
+
self._path(project_id, model, version), params=params
|
|
214
|
+
)
|
|
215
|
+
return [ModelArtifact.model_validate(item) for item in _response_list(response)]
|
|
216
|
+
|
|
217
|
+
def list_page(
|
|
218
|
+
self,
|
|
219
|
+
model: str,
|
|
220
|
+
version: str,
|
|
221
|
+
*,
|
|
222
|
+
project: ProjectRef | None = None,
|
|
223
|
+
include_trial_artifacts: bool = False,
|
|
224
|
+
) -> Page[ModelArtifact]:
|
|
225
|
+
"""Wrap the server's unpaginated artifact collection as one page."""
|
|
226
|
+
items = self.list(
|
|
227
|
+
model,
|
|
228
|
+
version,
|
|
229
|
+
project=project,
|
|
230
|
+
include_trial_artifacts=include_trial_artifacts,
|
|
231
|
+
)
|
|
232
|
+
return Page(items=items, total=len(items), page=1, limit=max(len(items), 1))
|
|
233
|
+
|
|
234
|
+
def iter_all(
|
|
235
|
+
self,
|
|
236
|
+
model: str,
|
|
237
|
+
version: str,
|
|
238
|
+
*,
|
|
239
|
+
project: ProjectRef | None = None,
|
|
240
|
+
include_trial_artifacts: bool = False,
|
|
241
|
+
) -> Iterator[ModelArtifact]:
|
|
242
|
+
"""Iterate the server's complete artifact collection."""
|
|
243
|
+
return iter(
|
|
244
|
+
self.list(
|
|
245
|
+
model,
|
|
246
|
+
version,
|
|
247
|
+
project=project,
|
|
248
|
+
include_trial_artifacts=include_trial_artifacts,
|
|
249
|
+
)
|
|
250
|
+
)
|
|
251
|
+
|
|
252
|
+
def get(
|
|
253
|
+
self,
|
|
254
|
+
model: str,
|
|
255
|
+
version: str,
|
|
256
|
+
artifact: str,
|
|
257
|
+
*,
|
|
258
|
+
project: ProjectRef | None = None,
|
|
259
|
+
) -> ModelArtifact:
|
|
260
|
+
"""Get an artifact by its natural names."""
|
|
261
|
+
project_id = self._resolve_project_id(project)
|
|
262
|
+
response = self._transport.get(
|
|
263
|
+
f"{self._path(project_id, model, version)}/{escape_path(artifact)}"
|
|
264
|
+
)
|
|
265
|
+
return ModelArtifact.model_validate(response_json(response))
|
|
266
|
+
|
|
267
|
+
def create(
|
|
268
|
+
self,
|
|
269
|
+
model: str,
|
|
270
|
+
version: str,
|
|
271
|
+
name: str,
|
|
272
|
+
uri: str,
|
|
273
|
+
*,
|
|
274
|
+
project: ProjectRef | None = None,
|
|
275
|
+
format: str | None = None,
|
|
276
|
+
platform: str | None = None,
|
|
277
|
+
storage_key: str | None = None,
|
|
278
|
+
size_bytes: int | None = None,
|
|
279
|
+
metadata: dict[str, Any] | None = None,
|
|
280
|
+
) -> ModelArtifact:
|
|
281
|
+
"""Create a non-base artifact using the existing registry route."""
|
|
282
|
+
project_id = self._resolve_project_id(project)
|
|
283
|
+
payload = _model_artifact_payload(
|
|
284
|
+
ModelArtifactCreate(
|
|
285
|
+
name=name,
|
|
286
|
+
uri=uri,
|
|
287
|
+
format=format,
|
|
288
|
+
platform=platform,
|
|
289
|
+
storage_key=storage_key,
|
|
290
|
+
size_bytes=size_bytes,
|
|
291
|
+
metadata=metadata,
|
|
292
|
+
)
|
|
293
|
+
)
|
|
294
|
+
response = self._transport.post(
|
|
295
|
+
self._path(project_id, model, version), json=payload
|
|
296
|
+
)
|
|
297
|
+
return ModelArtifact.model_validate(response_json(response))
|
|
298
|
+
|
|
299
|
+
def delete(
|
|
300
|
+
self,
|
|
301
|
+
model: str,
|
|
302
|
+
version: str,
|
|
303
|
+
artifact: str,
|
|
304
|
+
*,
|
|
305
|
+
project: ProjectRef | None = None,
|
|
306
|
+
) -> None:
|
|
307
|
+
"""Delete an artifact; artifact update is intentionally unsupported."""
|
|
308
|
+
project_id = self._resolve_project_id(project)
|
|
309
|
+
self._transport.delete(
|
|
310
|
+
f"{self._path(project_id, model, version)}/{escape_path(artifact)}"
|
|
311
|
+
)
|
|
312
|
+
|
|
313
|
+
|
|
314
|
+
class HuggingFaceImportsResource(BaseResource):
|
|
315
|
+
"""Hugging Face model import operations."""
|
|
316
|
+
|
|
317
|
+
def _path(self, project_id: int) -> str:
|
|
318
|
+
return f"/api/v1/projects/{project_id}/models/integration/huggingface/imports"
|
|
319
|
+
|
|
320
|
+
def create(
|
|
321
|
+
self,
|
|
322
|
+
repository: str,
|
|
323
|
+
*,
|
|
324
|
+
target_model_mode: str,
|
|
325
|
+
target_model: str,
|
|
326
|
+
target_version: str,
|
|
327
|
+
project: ProjectRef | None = None,
|
|
328
|
+
target_model_description: str | None = None,
|
|
329
|
+
storage_pvc: str | None = None,
|
|
330
|
+
) -> ModelImport:
|
|
331
|
+
"""Start a Hugging Face import."""
|
|
332
|
+
project_id = self._resolve_project_id(project)
|
|
333
|
+
response = self._transport.post(
|
|
334
|
+
self._path(project_id),
|
|
335
|
+
json=_without_none(
|
|
336
|
+
{
|
|
337
|
+
"repository": repository,
|
|
338
|
+
"targetModelMode": target_model_mode,
|
|
339
|
+
"targetModel": target_model,
|
|
340
|
+
"targetModelDescription": target_model_description,
|
|
341
|
+
"targetVersion": target_version,
|
|
342
|
+
"storagePvc": storage_pvc,
|
|
343
|
+
}
|
|
344
|
+
),
|
|
345
|
+
)
|
|
346
|
+
return ModelImport.model_validate(response_json(response))
|
|
347
|
+
|
|
348
|
+
def list(
|
|
349
|
+
self,
|
|
350
|
+
*,
|
|
351
|
+
project: ProjectRef | None = None,
|
|
352
|
+
page: int | None = None,
|
|
353
|
+
limit: int | None = None,
|
|
354
|
+
) -> list[ModelImport]:
|
|
355
|
+
"""Return one server page of Hugging Face imports."""
|
|
356
|
+
return self.list_page(project=project, page=page, limit=limit).items
|
|
357
|
+
|
|
358
|
+
def list_page(
|
|
359
|
+
self,
|
|
360
|
+
*,
|
|
361
|
+
project: ProjectRef | None = None,
|
|
362
|
+
page: int | None = None,
|
|
363
|
+
limit: int | None = None,
|
|
364
|
+
) -> Page[ModelImport]:
|
|
365
|
+
"""Return one Hugging Face import page."""
|
|
366
|
+
project_id = self._resolve_project_id(project)
|
|
367
|
+
params, resolved_page, resolved_limit = self._pagination_params(
|
|
368
|
+
page, limit, default_page=1, default_limit=10
|
|
369
|
+
)
|
|
370
|
+
payload = response_json(
|
|
371
|
+
self._transport.get(self._path(project_id), params=params)
|
|
372
|
+
)
|
|
373
|
+
return self._page(
|
|
374
|
+
payload,
|
|
375
|
+
ModelImport,
|
|
376
|
+
item_keys=("jobs",),
|
|
377
|
+
page=resolved_page,
|
|
378
|
+
limit=resolved_limit,
|
|
379
|
+
)
|
|
380
|
+
|
|
381
|
+
def iter_all(
|
|
382
|
+
self,
|
|
383
|
+
*,
|
|
384
|
+
project: ProjectRef | None = None,
|
|
385
|
+
limit: int = 100,
|
|
386
|
+
) -> Iterator[ModelImport]:
|
|
387
|
+
"""Iterate all Hugging Face imports in server order."""
|
|
388
|
+
return self._iter_all(
|
|
389
|
+
lambda page, page_limit: self.list_page(
|
|
390
|
+
project=project, page=page, limit=page_limit
|
|
391
|
+
),
|
|
392
|
+
limit=limit,
|
|
393
|
+
)
|
|
394
|
+
|
|
395
|
+
def mappings(
|
|
396
|
+
self, *, project: ProjectRef | None = None
|
|
397
|
+
) -> list[HuggingFaceMapping]:
|
|
398
|
+
"""List completed Hugging Face repository mappings."""
|
|
399
|
+
project_id = self._resolve_project_id(project)
|
|
400
|
+
path = f"/api/v1/projects/{project_id}/models/integration/huggingface/mappings"
|
|
401
|
+
return [
|
|
402
|
+
HuggingFaceMapping.model_validate(item)
|
|
403
|
+
for item in _response_list(self._transport.get(path))
|
|
404
|
+
]
|
|
405
|
+
|
|
406
|
+
def wait(
|
|
407
|
+
self,
|
|
408
|
+
import_id: int,
|
|
409
|
+
*,
|
|
410
|
+
project: ProjectRef | None = None,
|
|
411
|
+
timeout: float = 1800,
|
|
412
|
+
interval: float = 5,
|
|
413
|
+
) -> ModelImport:
|
|
414
|
+
"""Wait for an exact Hugging Face import using the list route."""
|
|
415
|
+
deadline, interval = _wait_values(timeout, interval)
|
|
416
|
+
while True:
|
|
417
|
+
job = next(
|
|
418
|
+
(
|
|
419
|
+
item
|
|
420
|
+
for item in self.iter_all(project=project)
|
|
421
|
+
if item.id == import_id
|
|
422
|
+
),
|
|
423
|
+
None,
|
|
424
|
+
)
|
|
425
|
+
if job is None:
|
|
426
|
+
raise NotFoundError(f"Hugging Face import not found: {import_id}")
|
|
427
|
+
if job.state in _IMPORT_TERMINAL_STATES:
|
|
428
|
+
return job
|
|
429
|
+
remaining = deadline - time.monotonic()
|
|
430
|
+
if remaining <= 0:
|
|
431
|
+
raise TimeoutError(
|
|
432
|
+
f"Timed out waiting for Hugging Face import {import_id}; "
|
|
433
|
+
f"last state: {job.state}"
|
|
434
|
+
)
|
|
435
|
+
time.sleep(min(interval, remaining))
|
|
436
|
+
|
|
437
|
+
|
|
438
|
+
class MLflowImportsResource(BaseResource):
|
|
439
|
+
"""MLflow model import operations."""
|
|
440
|
+
|
|
441
|
+
def _path(self, project_id: int) -> str:
|
|
442
|
+
return f"/api/v1/projects/{project_id}/models/integration/mlflow"
|
|
443
|
+
|
|
444
|
+
def create(
|
|
445
|
+
self,
|
|
446
|
+
mlflow_url: str,
|
|
447
|
+
run_id: str,
|
|
448
|
+
artifact_path: str,
|
|
449
|
+
*,
|
|
450
|
+
target_model_mode: str,
|
|
451
|
+
target_model: str,
|
|
452
|
+
target_version: str,
|
|
453
|
+
project: ProjectRef | None = None,
|
|
454
|
+
target_model_description: str | None = None,
|
|
455
|
+
storage_pvc: str | None = None,
|
|
456
|
+
) -> ModelImport:
|
|
457
|
+
"""Start an MLflow import."""
|
|
458
|
+
project_id = self._resolve_project_id(project)
|
|
459
|
+
response = self._transport.post(
|
|
460
|
+
f"{self._path(project_id)}/import",
|
|
461
|
+
json=_without_none(
|
|
462
|
+
{
|
|
463
|
+
"mlflowUrl": mlflow_url,
|
|
464
|
+
"runId": run_id,
|
|
465
|
+
"artifactPath": artifact_path,
|
|
466
|
+
"targetModelMode": target_model_mode,
|
|
467
|
+
"targetModel": target_model,
|
|
468
|
+
"targetModelDescription": target_model_description,
|
|
469
|
+
"targetVersion": target_version,
|
|
470
|
+
"storagePvc": storage_pvc,
|
|
471
|
+
}
|
|
472
|
+
),
|
|
473
|
+
)
|
|
474
|
+
return ModelImport.model_validate(response_json(response))
|
|
475
|
+
|
|
476
|
+
def list(
|
|
477
|
+
self,
|
|
478
|
+
*,
|
|
479
|
+
project: ProjectRef | None = None,
|
|
480
|
+
page: int | None = None,
|
|
481
|
+
limit: int | None = None,
|
|
482
|
+
) -> list[ModelImport]:
|
|
483
|
+
"""Return one server page of MLflow imports."""
|
|
484
|
+
return self.list_page(project=project, page=page, limit=limit).items
|
|
485
|
+
|
|
486
|
+
def list_page(
|
|
487
|
+
self,
|
|
488
|
+
*,
|
|
489
|
+
project: ProjectRef | None = None,
|
|
490
|
+
page: int | None = None,
|
|
491
|
+
limit: int | None = None,
|
|
492
|
+
) -> Page[ModelImport]:
|
|
493
|
+
"""Return one MLflow import page."""
|
|
494
|
+
project_id = self._resolve_project_id(project)
|
|
495
|
+
params, resolved_page, resolved_limit = self._pagination_params(
|
|
496
|
+
page, limit, default_page=1, default_limit=10
|
|
497
|
+
)
|
|
498
|
+
payload = response_json(
|
|
499
|
+
self._transport.get(f"{self._path(project_id)}/imports", params=params)
|
|
500
|
+
)
|
|
501
|
+
return self._page(
|
|
502
|
+
payload,
|
|
503
|
+
ModelImport,
|
|
504
|
+
item_keys=("jobs",),
|
|
505
|
+
page=resolved_page,
|
|
506
|
+
limit=resolved_limit,
|
|
507
|
+
)
|
|
508
|
+
|
|
509
|
+
def iter_all(
|
|
510
|
+
self,
|
|
511
|
+
*,
|
|
512
|
+
project: ProjectRef | None = None,
|
|
513
|
+
limit: int = 100,
|
|
514
|
+
) -> Iterator[ModelImport]:
|
|
515
|
+
"""Iterate all MLflow imports in server order."""
|
|
516
|
+
return self._iter_all(
|
|
517
|
+
lambda page, page_limit: self.list_page(
|
|
518
|
+
project=project, page=page, limit=page_limit
|
|
519
|
+
),
|
|
520
|
+
limit=limit,
|
|
521
|
+
)
|
|
522
|
+
|
|
523
|
+
def get(self, import_id: int, *, project: ProjectRef | None = None) -> ModelImport:
|
|
524
|
+
"""Get one MLflow import by ID."""
|
|
525
|
+
project_id = self._resolve_project_id(project)
|
|
526
|
+
response = self._transport.get(f"{self._path(project_id)}/imports/{import_id}")
|
|
527
|
+
return ModelImport.model_validate(response_json(response))
|
|
528
|
+
|
|
529
|
+
def wait(
|
|
530
|
+
self,
|
|
531
|
+
import_id: int,
|
|
532
|
+
*,
|
|
533
|
+
project: ProjectRef | None = None,
|
|
534
|
+
timeout: float = 1800,
|
|
535
|
+
interval: float = 5,
|
|
536
|
+
) -> ModelImport:
|
|
537
|
+
"""Wait for an MLflow import using its single-job GET route."""
|
|
538
|
+
deadline, interval = _wait_values(timeout, interval)
|
|
539
|
+
while True:
|
|
540
|
+
job = self.get(import_id, project=project)
|
|
541
|
+
if job.state in _IMPORT_TERMINAL_STATES:
|
|
542
|
+
return job
|
|
543
|
+
remaining = deadline - time.monotonic()
|
|
544
|
+
if remaining <= 0:
|
|
545
|
+
raise TimeoutError(
|
|
546
|
+
f"Timed out waiting for MLflow import {import_id}; "
|
|
547
|
+
f"last state: {job.state}"
|
|
548
|
+
)
|
|
549
|
+
time.sleep(min(interval, remaining))
|
|
550
|
+
|
|
551
|
+
|
|
552
|
+
class ModelImportsResource:
|
|
553
|
+
"""Explicit Hugging Face and MLflow import resources."""
|
|
554
|
+
|
|
555
|
+
def __init__(self, transport: Any, default_project: ProjectRef | None = None):
|
|
556
|
+
self.huggingface = HuggingFaceImportsResource(transport, default_project)
|
|
557
|
+
self.mlflow = MLflowImportsResource(transport, default_project)
|
|
558
|
+
|
|
559
|
+
|
|
560
|
+
class ModelsResource(BaseResource):
|
|
561
|
+
"""Registered model operations and model registry subresources."""
|
|
562
|
+
|
|
563
|
+
def __init__(self, *args: Any, **kwargs: Any):
|
|
564
|
+
super().__init__(*args, **kwargs)
|
|
565
|
+
resource_args = (self._transport, self._default_project)
|
|
566
|
+
self.versions = ModelVersionsResource(*resource_args)
|
|
567
|
+
self.artifacts = ModelArtifactsResource(*resource_args)
|
|
568
|
+
self.imports = ModelImportsResource(*resource_args)
|
|
569
|
+
|
|
570
|
+
def get_artifact(
|
|
571
|
+
self,
|
|
572
|
+
model: str,
|
|
573
|
+
version: str,
|
|
574
|
+
artifact: str,
|
|
575
|
+
*,
|
|
576
|
+
project: ProjectRef | None = None,
|
|
577
|
+
) -> ModelArtifact:
|
|
578
|
+
"""Get an artifact through the legacy convenience method."""
|
|
579
|
+
return self.artifacts.get(model, version, artifact, project=project)
|
|
580
|
+
|
|
581
|
+
def list(
|
|
582
|
+
self,
|
|
583
|
+
*,
|
|
584
|
+
project: ProjectRef | None = None,
|
|
585
|
+
search: str | None = None,
|
|
586
|
+
page: int | None = None,
|
|
587
|
+
limit: int | None = None,
|
|
588
|
+
) -> list[RegisteredModel]:
|
|
589
|
+
"""Return one server page of registered models."""
|
|
590
|
+
project_id = self._resolve_project_id(project)
|
|
591
|
+
params, _, _ = self._pagination_params(page, limit)
|
|
592
|
+
if search:
|
|
593
|
+
params["search"] = search
|
|
594
|
+
response = self._transport.get(
|
|
595
|
+
f"/api/v1/projects/{project_id}/models", params=params
|
|
596
|
+
)
|
|
597
|
+
payload = response_json(response)
|
|
598
|
+
return [
|
|
599
|
+
RegisteredModel.model_validate(model)
|
|
600
|
+
for model in payload.get("models", [])
|
|
601
|
+
if isinstance(model, dict)
|
|
602
|
+
]
|
|
603
|
+
|
|
604
|
+
def list_page(
|
|
605
|
+
self,
|
|
606
|
+
*,
|
|
607
|
+
project: ProjectRef | None = None,
|
|
608
|
+
search: str | None = None,
|
|
609
|
+
page: int | None = None,
|
|
610
|
+
limit: int | None = None,
|
|
611
|
+
) -> Page[RegisteredModel]:
|
|
612
|
+
"""Return one model page with server pagination metadata."""
|
|
613
|
+
project_id = self._resolve_project_id(project)
|
|
614
|
+
params, resolved_page, resolved_limit = self._pagination_params(
|
|
615
|
+
page,
|
|
616
|
+
limit,
|
|
617
|
+
default_page=1,
|
|
618
|
+
default_limit=10,
|
|
619
|
+
)
|
|
620
|
+
if search:
|
|
621
|
+
params["search"] = search
|
|
622
|
+
response = self._transport.get(
|
|
623
|
+
f"/api/v1/projects/{project_id}/models", params=params
|
|
624
|
+
)
|
|
625
|
+
return self._page(
|
|
626
|
+
response_json(response),
|
|
627
|
+
RegisteredModel,
|
|
628
|
+
item_keys=("models",),
|
|
629
|
+
page=resolved_page,
|
|
630
|
+
limit=resolved_limit,
|
|
631
|
+
)
|
|
632
|
+
|
|
633
|
+
def iter_all(
|
|
634
|
+
self,
|
|
635
|
+
*,
|
|
636
|
+
project: ProjectRef | None = None,
|
|
637
|
+
search: str | None = None,
|
|
638
|
+
limit: int = 100,
|
|
639
|
+
) -> Iterator[RegisteredModel]:
|
|
640
|
+
"""Iterate all matching models in server order."""
|
|
641
|
+
return self._iter_all(
|
|
642
|
+
lambda page, page_limit: self.list_page(
|
|
643
|
+
project=project,
|
|
644
|
+
search=search,
|
|
645
|
+
page=page,
|
|
646
|
+
limit=page_limit,
|
|
647
|
+
),
|
|
648
|
+
limit=limit,
|
|
649
|
+
)
|
|
650
|
+
|
|
651
|
+
def create(
|
|
652
|
+
self,
|
|
653
|
+
name: str,
|
|
654
|
+
*,
|
|
655
|
+
project: ProjectRef | None = None,
|
|
656
|
+
description: str | None = None,
|
|
657
|
+
author: str | None = None,
|
|
658
|
+
) -> RegisteredModel:
|
|
659
|
+
"""Create a registered model."""
|
|
660
|
+
project_id = self._resolve_project_id(project)
|
|
661
|
+
payload = {"name": name}
|
|
662
|
+
if description is not None:
|
|
663
|
+
payload["description"] = description
|
|
664
|
+
if author is not None:
|
|
665
|
+
payload["author"] = author
|
|
666
|
+
response = self._transport.post(
|
|
667
|
+
f"/api/v1/projects/{project_id}/models",
|
|
668
|
+
json=payload,
|
|
669
|
+
)
|
|
670
|
+
return RegisteredModel.model_validate(response_json(response))
|
|
671
|
+
|
|
672
|
+
def get(self, name: str, *, project: ProjectRef | None = None) -> ModelDetail:
|
|
673
|
+
"""Get a registered model with its versions."""
|
|
674
|
+
project_id = self._resolve_project_id(project)
|
|
675
|
+
response = self._transport.get(
|
|
676
|
+
f"/api/v1/projects/{project_id}/models/{escape_path(name)}"
|
|
677
|
+
)
|
|
678
|
+
return ModelDetail.model_validate(response_json(response))
|
|
679
|
+
|
|
680
|
+
def update(
|
|
681
|
+
self,
|
|
682
|
+
name: str,
|
|
683
|
+
*,
|
|
684
|
+
description: str | None,
|
|
685
|
+
project: ProjectRef | None = None,
|
|
686
|
+
) -> RegisteredModel:
|
|
687
|
+
"""Update a registered model description."""
|
|
688
|
+
project_id = self._resolve_project_id(project)
|
|
689
|
+
response = self._transport.patch(
|
|
690
|
+
f"/api/v1/projects/{project_id}/models/{escape_path(name)}",
|
|
691
|
+
json={"description": description},
|
|
692
|
+
)
|
|
693
|
+
return RegisteredModel.model_validate(response_json(response))
|
|
694
|
+
|
|
695
|
+
def validate(
|
|
696
|
+
self,
|
|
697
|
+
uri: str,
|
|
698
|
+
*,
|
|
699
|
+
project: ProjectRef | None = None,
|
|
700
|
+
platform: str | None = None,
|
|
701
|
+
model_name: str | None = None,
|
|
702
|
+
version: str | None = None,
|
|
703
|
+
force: bool = False,
|
|
704
|
+
) -> ArtifactValidation:
|
|
705
|
+
"""Validate an artifact source through the model registry."""
|
|
706
|
+
project_id = self._resolve_project_id(project)
|
|
707
|
+
payload = _without_none(
|
|
708
|
+
{
|
|
709
|
+
"uri": uri,
|
|
710
|
+
"platform": platform,
|
|
711
|
+
"modelName": model_name,
|
|
712
|
+
"version": version,
|
|
713
|
+
"force": force if force else None,
|
|
714
|
+
}
|
|
715
|
+
)
|
|
716
|
+
response = self._transport.post(
|
|
717
|
+
f"/api/v1/projects/{project_id}/models/validate", json=payload
|
|
718
|
+
)
|
|
719
|
+
return ArtifactValidation.model_validate(response_json(response))
|
|
720
|
+
|
|
721
|
+
def delete(self, name: str, *, project: ProjectRef | None = None) -> None:
|
|
722
|
+
"""Delete a registered model."""
|
|
723
|
+
project_id = self._resolve_project_id(project)
|
|
724
|
+
self._transport.delete(
|
|
725
|
+
f"/api/v1/projects/{project_id}/models/{escape_path(name)}"
|
|
726
|
+
)
|