deapi-sdk 0.6.1__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.
- deapi_sdk/__init__.py +409 -0
- deapi_sdk/_cards.py +313 -0
- deapi_sdk/_client.py +411 -0
- deapi_sdk/_config.py +77 -0
- deapi_sdk/_constants.py +61 -0
- deapi_sdk/_download.py +37 -0
- deapi_sdk/_exceptions.py +184 -0
- deapi_sdk/_files.py +59 -0
- deapi_sdk/_payload.py +50 -0
- deapi_sdk/_polling.py +157 -0
- deapi_sdk/_realtime/__init__.py +7 -0
- deapi_sdk/_realtime/_discovery.py +43 -0
- deapi_sdk/_realtime/_engine.py +419 -0
- deapi_sdk/_realtime/_protocol.py +152 -0
- deapi_sdk/_realtime/_session.py +529 -0
- deapi_sdk/_types.py +31 -0
- deapi_sdk/_version.py +3 -0
- deapi_sdk/py.typed +0 -0
- deapi_sdk/resources/__init__.py +35 -0
- deapi_sdk/resources/account.py +149 -0
- deapi_sdk/resources/audio.py +386 -0
- deapi_sdk/resources/embeddings.py +116 -0
- deapi_sdk/resources/images.py +616 -0
- deapi_sdk/resources/keys.py +277 -0
- deapi_sdk/resources/models.py +161 -0
- deapi_sdk/resources/ocr.py +152 -0
- deapi_sdk/resources/prompts.py +137 -0
- deapi_sdk/resources/transcription.py +308 -0
- deapi_sdk/resources/video.py +985 -0
- deapi_sdk/transcript.py +142 -0
- deapi_sdk/types/__init__.py +68 -0
- deapi_sdk/types/account.py +115 -0
- deapi_sdk/types/audio.py +35 -0
- deapi_sdk/types/common.py +174 -0
- deapi_sdk/types/embeddings.py +11 -0
- deapi_sdk/types/images.py +40 -0
- deapi_sdk/types/keys.py +53 -0
- deapi_sdk/types/ocr.py +14 -0
- deapi_sdk/types/prompts.py +26 -0
- deapi_sdk/types/transcription.py +14 -0
- deapi_sdk/types/video.py +84 -0
- deapi_sdk/types/websocket.py +36 -0
- deapi_sdk/webhook.py +159 -0
- deapi_sdk-0.6.1.dist-info/METADATA +644 -0
- deapi_sdk-0.6.1.dist-info/RECORD +47 -0
- deapi_sdk-0.6.1.dist-info/WHEEL +4 -0
- deapi_sdk-0.6.1.dist-info/licenses/LICENSE +21 -0
|
@@ -0,0 +1,277 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
import builtins
|
|
4
|
+
from datetime import date, datetime
|
|
5
|
+
from typing import Any
|
|
6
|
+
|
|
7
|
+
from deapi_sdk._client import AsyncHTTPClient, SyncHTTPClient
|
|
8
|
+
from deapi_sdk.resources.account import page_params, parse_usage, unwrap, usage_params
|
|
9
|
+
from deapi_sdk.types.account import UsageReport
|
|
10
|
+
from deapi_sdk.types.keys import ApiKey, ApiKeyCreated, ApiKeysPage
|
|
11
|
+
|
|
12
|
+
# Sentinel: a field that was not passed must not be sent in a PATCH (None means "clear it").
|
|
13
|
+
_UNSET: Any = object()
|
|
14
|
+
|
|
15
|
+
|
|
16
|
+
def _iso(value: Any) -> Any:
|
|
17
|
+
return value.isoformat() if isinstance(value, (datetime, date)) else value
|
|
18
|
+
|
|
19
|
+
|
|
20
|
+
def _create_body(
|
|
21
|
+
name: str,
|
|
22
|
+
expires_at: Any,
|
|
23
|
+
limit: float | None,
|
|
24
|
+
reset_interval: str | None,
|
|
25
|
+
ip_whitelist: list[str] | None,
|
|
26
|
+
role: str | None,
|
|
27
|
+
extra: dict[str, Any],
|
|
28
|
+
) -> dict[str, Any]:
|
|
29
|
+
body: dict[str, Any] = {"name": name}
|
|
30
|
+
for key, value in (
|
|
31
|
+
("role", role),
|
|
32
|
+
("expires_at", _iso(expires_at)),
|
|
33
|
+
("limit", limit),
|
|
34
|
+
("reset_interval", reset_interval),
|
|
35
|
+
("ip_whitelist", ip_whitelist),
|
|
36
|
+
):
|
|
37
|
+
if value is not None:
|
|
38
|
+
body[key] = value
|
|
39
|
+
body.update(extra)
|
|
40
|
+
return body
|
|
41
|
+
|
|
42
|
+
|
|
43
|
+
def _update_body(fields: dict[str, Any], extra: dict[str, Any]) -> dict[str, Any]:
|
|
44
|
+
body = {k: _iso(v) for k, v in fields.items() if v is not _UNSET}
|
|
45
|
+
body.update(extra)
|
|
46
|
+
return body
|
|
47
|
+
|
|
48
|
+
|
|
49
|
+
class KeysResource:
|
|
50
|
+
"""API key inspection and management (API v2).
|
|
51
|
+
|
|
52
|
+
``current()`` and ``current_usage()`` work with any key. Everything else needs an ADMIN key
|
|
53
|
+
(API-role keys get 403 ``insufficient_permissions``).
|
|
54
|
+
"""
|
|
55
|
+
|
|
56
|
+
def __init__(self, client: SyncHTTPClient) -> None:
|
|
57
|
+
self._client = client
|
|
58
|
+
|
|
59
|
+
def _key_url(self, key_id: int | str) -> str:
|
|
60
|
+
return f"{self._client._resolve_endpoint('keys')}/{key_id}"
|
|
61
|
+
|
|
62
|
+
def current(self) -> ApiKey:
|
|
63
|
+
"""The key sending the request (``GET /key``). Works with any key role."""
|
|
64
|
+
return ApiKey.model_validate(unwrap(self._client.get(self._client._resolve_endpoint("key"))))
|
|
65
|
+
|
|
66
|
+
def current_usage(
|
|
67
|
+
self,
|
|
68
|
+
*,
|
|
69
|
+
from_: str | date | datetime | None = None,
|
|
70
|
+
to: str | date | datetime | None = None,
|
|
71
|
+
group_by: str | None = None,
|
|
72
|
+
**params: Any,
|
|
73
|
+
) -> UsageReport:
|
|
74
|
+
"""Usage of the calling key (``GET /key/usage``). Works with any key role.
|
|
75
|
+
|
|
76
|
+
``group_by`` is one of ``day``, ``hour``, ``type``, ``model``.
|
|
77
|
+
"""
|
|
78
|
+
url = self._client._resolve_endpoint("key_usage")
|
|
79
|
+
return parse_usage(self._client.get(url, params=usage_params(from_, to, group_by, params)))
|
|
80
|
+
|
|
81
|
+
def list(
|
|
82
|
+
self,
|
|
83
|
+
*,
|
|
84
|
+
limit: int | None = None,
|
|
85
|
+
page: int | None = None,
|
|
86
|
+
per_page: int | None = None,
|
|
87
|
+
**params: Any,
|
|
88
|
+
) -> ApiKeysPage:
|
|
89
|
+
"""One page of the account's keys (``GET /keys``). ADMIN key only.
|
|
90
|
+
|
|
91
|
+
``limit`` is the page size (default 50, max 100; ``per_page`` is an alias, ``limit`` wins).
|
|
92
|
+
"""
|
|
93
|
+
resp = self._client.get(
|
|
94
|
+
self._client._resolve_endpoint("keys"),
|
|
95
|
+
params=page_params(limit, page, per_page, params),
|
|
96
|
+
)
|
|
97
|
+
return ApiKeysPage.model_validate(resp)
|
|
98
|
+
|
|
99
|
+
def get(self, key_id: int | str) -> ApiKey:
|
|
100
|
+
"""One key by id (``GET /keys/{id}``). ADMIN key only."""
|
|
101
|
+
return ApiKey.model_validate(unwrap(self._client.get(self._key_url(key_id))))
|
|
102
|
+
|
|
103
|
+
def usage(
|
|
104
|
+
self,
|
|
105
|
+
key_id: int | str,
|
|
106
|
+
*,
|
|
107
|
+
from_: str | date | datetime | None = None,
|
|
108
|
+
to: str | date | datetime | None = None,
|
|
109
|
+
group_by: str | None = None,
|
|
110
|
+
**params: Any,
|
|
111
|
+
) -> UsageReport:
|
|
112
|
+
"""Usage of any key of the account (``GET /keys/{id}/usage``). ADMIN key only."""
|
|
113
|
+
url = f"{self._key_url(key_id)}/usage"
|
|
114
|
+
return parse_usage(self._client.get(url, params=usage_params(from_, to, group_by, params)))
|
|
115
|
+
|
|
116
|
+
def create(
|
|
117
|
+
self,
|
|
118
|
+
*,
|
|
119
|
+
name: str,
|
|
120
|
+
expires_at: str | date | datetime | None = None,
|
|
121
|
+
limit: float | None = None,
|
|
122
|
+
reset_interval: str | None = None,
|
|
123
|
+
ip_whitelist: builtins.list[str] | None = None,
|
|
124
|
+
role: str | None = None,
|
|
125
|
+
**extra: Any,
|
|
126
|
+
) -> ApiKeyCreated:
|
|
127
|
+
"""Create an API-role key (``POST /keys``). ADMIN key only.
|
|
128
|
+
|
|
129
|
+
``reset_interval`` is ``none`` (default), ``daily``, ``weekly`` or ``monthly``; ``limit`` is the spend cap
|
|
130
|
+
(0-999999.999999, ``None`` = unlimited); ``ip_whitelist`` holds at most 20 entries. ``role`` is
|
|
131
|
+
``api`` (default); the created key's ``role`` is always ``api``.
|
|
132
|
+
The returned ``secret`` is shown ONCE; store it immediately.
|
|
133
|
+
"""
|
|
134
|
+
body = _create_body(name, expires_at, limit, reset_interval, ip_whitelist, role, extra)
|
|
135
|
+
resp = self._client.request("POST", self._client._resolve_endpoint("keys"), json=body)
|
|
136
|
+
return ApiKeyCreated.model_validate(unwrap(resp))
|
|
137
|
+
|
|
138
|
+
def update(
|
|
139
|
+
self,
|
|
140
|
+
key_id: int | str,
|
|
141
|
+
*,
|
|
142
|
+
active: bool = _UNSET,
|
|
143
|
+
expires_at: str | date | datetime | None = _UNSET,
|
|
144
|
+
limit: float | None = _UNSET,
|
|
145
|
+
reset_interval: str | None = _UNSET,
|
|
146
|
+
ip_whitelist: builtins.list[str] | None = _UNSET,
|
|
147
|
+
**extra: Any,
|
|
148
|
+
) -> ApiKey:
|
|
149
|
+
"""Change a key (``PATCH /keys/{id}``). ADMIN key only.
|
|
150
|
+
|
|
151
|
+
Only the fields you pass are sent; pass ``None`` to clear ``expires_at`` / ``limit``. Disable a key
|
|
152
|
+
with ``active=False`` and re-enable it with ``active=True`` (the key's ``status`` then reads
|
|
153
|
+
``revoked`` / ``active``).
|
|
154
|
+
"""
|
|
155
|
+
body = _update_body(
|
|
156
|
+
{
|
|
157
|
+
"active": active,
|
|
158
|
+
"expires_at": expires_at,
|
|
159
|
+
"limit": limit,
|
|
160
|
+
"reset_interval": reset_interval,
|
|
161
|
+
"ip_whitelist": ip_whitelist,
|
|
162
|
+
},
|
|
163
|
+
extra,
|
|
164
|
+
)
|
|
165
|
+
resp = self._client.request("PATCH", self._key_url(key_id), json=body)
|
|
166
|
+
return ApiKey.model_validate(unwrap(resp))
|
|
167
|
+
|
|
168
|
+
def delete(self, key_id: int | str) -> None:
|
|
169
|
+
"""Permanently delete an API-role key (``DELETE /keys/{id}``). ADMIN key only."""
|
|
170
|
+
self._client.request("DELETE", self._key_url(key_id))
|
|
171
|
+
|
|
172
|
+
|
|
173
|
+
class AsyncKeysResource:
|
|
174
|
+
"""Async variant of :class:`KeysResource`."""
|
|
175
|
+
|
|
176
|
+
def __init__(self, client: AsyncHTTPClient) -> None:
|
|
177
|
+
self._client = client
|
|
178
|
+
|
|
179
|
+
def _key_url(self, key_id: int | str) -> str:
|
|
180
|
+
return f"{self._client._resolve_endpoint('keys')}/{key_id}"
|
|
181
|
+
|
|
182
|
+
async def current(self) -> ApiKey:
|
|
183
|
+
"""The key sending the request (``GET /key``). Works with any key role."""
|
|
184
|
+
return ApiKey.model_validate(unwrap(await self._client.get(self._client._resolve_endpoint("key"))))
|
|
185
|
+
|
|
186
|
+
async def current_usage(
|
|
187
|
+
self,
|
|
188
|
+
*,
|
|
189
|
+
from_: str | date | datetime | None = None,
|
|
190
|
+
to: str | date | datetime | None = None,
|
|
191
|
+
group_by: str | None = None,
|
|
192
|
+
**params: Any,
|
|
193
|
+
) -> UsageReport:
|
|
194
|
+
"""Usage of the calling key (``GET /key/usage``). Works with any key role."""
|
|
195
|
+
url = self._client._resolve_endpoint("key_usage")
|
|
196
|
+
return parse_usage(await self._client.get(url, params=usage_params(from_, to, group_by, params)))
|
|
197
|
+
|
|
198
|
+
async def list(
|
|
199
|
+
self,
|
|
200
|
+
*,
|
|
201
|
+
limit: int | None = None,
|
|
202
|
+
page: int | None = None,
|
|
203
|
+
per_page: int | None = None,
|
|
204
|
+
**params: Any,
|
|
205
|
+
) -> ApiKeysPage:
|
|
206
|
+
"""One page of the account's keys (``GET /keys``). ADMIN key only. See ``KeysResource.list``."""
|
|
207
|
+
resp = await self._client.get(
|
|
208
|
+
self._client._resolve_endpoint("keys"), params=page_params(limit, page, per_page, params)
|
|
209
|
+
)
|
|
210
|
+
return ApiKeysPage.model_validate(resp)
|
|
211
|
+
|
|
212
|
+
async def get(self, key_id: int | str) -> ApiKey:
|
|
213
|
+
"""One key by id (``GET /keys/{id}``). ADMIN key only."""
|
|
214
|
+
return ApiKey.model_validate(unwrap(await self._client.get(self._key_url(key_id))))
|
|
215
|
+
|
|
216
|
+
async def usage(
|
|
217
|
+
self,
|
|
218
|
+
key_id: int | str,
|
|
219
|
+
*,
|
|
220
|
+
from_: str | date | datetime | None = None,
|
|
221
|
+
to: str | date | datetime | None = None,
|
|
222
|
+
group_by: str | None = None,
|
|
223
|
+
**params: Any,
|
|
224
|
+
) -> UsageReport:
|
|
225
|
+
"""Usage of any key of the account (``GET /keys/{id}/usage``). ADMIN key only."""
|
|
226
|
+
url = f"{self._key_url(key_id)}/usage"
|
|
227
|
+
return parse_usage(await self._client.get(url, params=usage_params(from_, to, group_by, params)))
|
|
228
|
+
|
|
229
|
+
async def create(
|
|
230
|
+
self,
|
|
231
|
+
*,
|
|
232
|
+
name: str,
|
|
233
|
+
expires_at: str | date | datetime | None = None,
|
|
234
|
+
limit: float | None = None,
|
|
235
|
+
reset_interval: str | None = None,
|
|
236
|
+
ip_whitelist: builtins.list[str] | None = None,
|
|
237
|
+
role: str | None = None,
|
|
238
|
+
**extra: Any,
|
|
239
|
+
) -> ApiKeyCreated:
|
|
240
|
+
"""Create an API-role key (``POST /keys``). ADMIN key only. The ``secret`` is shown ONCE."""
|
|
241
|
+
body = _create_body(name, expires_at, limit, reset_interval, ip_whitelist, role, extra)
|
|
242
|
+
resp = await self._client.request("POST", self._client._resolve_endpoint("keys"), json=body)
|
|
243
|
+
return ApiKeyCreated.model_validate(unwrap(resp))
|
|
244
|
+
|
|
245
|
+
async def update(
|
|
246
|
+
self,
|
|
247
|
+
key_id: int | str,
|
|
248
|
+
*,
|
|
249
|
+
active: bool = _UNSET,
|
|
250
|
+
expires_at: str | date | datetime | None = _UNSET,
|
|
251
|
+
limit: float | None = _UNSET,
|
|
252
|
+
reset_interval: str | None = _UNSET,
|
|
253
|
+
ip_whitelist: builtins.list[str] | None = _UNSET,
|
|
254
|
+
**extra: Any,
|
|
255
|
+
) -> ApiKey:
|
|
256
|
+
"""Change a key (``PATCH /keys/{id}``). ADMIN key only.
|
|
257
|
+
|
|
258
|
+
Only the fields you pass are sent; pass ``None`` to clear ``expires_at`` / ``limit``. Disable a key
|
|
259
|
+
with ``active=False`` and re-enable it with ``active=True`` (the key's ``status`` then reads
|
|
260
|
+
``revoked`` / ``active``).
|
|
261
|
+
"""
|
|
262
|
+
body = _update_body(
|
|
263
|
+
{
|
|
264
|
+
"active": active,
|
|
265
|
+
"expires_at": expires_at,
|
|
266
|
+
"limit": limit,
|
|
267
|
+
"reset_interval": reset_interval,
|
|
268
|
+
"ip_whitelist": ip_whitelist,
|
|
269
|
+
},
|
|
270
|
+
extra,
|
|
271
|
+
)
|
|
272
|
+
resp = await self._client.request("PATCH", self._key_url(key_id), json=body)
|
|
273
|
+
return ApiKey.model_validate(unwrap(resp))
|
|
274
|
+
|
|
275
|
+
async def delete(self, key_id: int | str) -> None:
|
|
276
|
+
"""Permanently delete an API-role key (``DELETE /keys/{id}``). ADMIN key only."""
|
|
277
|
+
await self._client.request("DELETE", self._key_url(key_id))
|
|
@@ -0,0 +1,161 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
import builtins
|
|
4
|
+
import warnings
|
|
5
|
+
from typing import Any
|
|
6
|
+
|
|
7
|
+
from deapi_sdk._client import AsyncHTTPClient, SyncHTTPClient
|
|
8
|
+
from deapi_sdk.types.common import ModelInfo, ModelsResponse
|
|
9
|
+
|
|
10
|
+
# Server-side page-size cap for GET /models (``limit`` is capped at 50 by the API).
|
|
11
|
+
MAX_PAGE_SIZE = 50
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
def _build_params(
|
|
15
|
+
limit: int | None,
|
|
16
|
+
page: int,
|
|
17
|
+
inference_types: list[str] | None,
|
|
18
|
+
per_page: int | None,
|
|
19
|
+
tags: list[str] | None = None,
|
|
20
|
+
sort: str | None = None,
|
|
21
|
+
) -> dict[str, Any]:
|
|
22
|
+
if per_page is not None:
|
|
23
|
+
warnings.warn(
|
|
24
|
+
"'per_page' is a deprecated alias of 'limit'; use 'limit' instead.",
|
|
25
|
+
DeprecationWarning,
|
|
26
|
+
stacklevel=3,
|
|
27
|
+
)
|
|
28
|
+
if limit is None:
|
|
29
|
+
limit = per_page
|
|
30
|
+
params: dict[str, Any] = {"page": page}
|
|
31
|
+
if limit is not None:
|
|
32
|
+
params["limit"] = limit
|
|
33
|
+
if inference_types is not None:
|
|
34
|
+
params["filter[inference_types]"] = ",".join(inference_types)
|
|
35
|
+
if tags is not None:
|
|
36
|
+
params["filter[tags]"] = ",".join(tags)
|
|
37
|
+
if sort is not None:
|
|
38
|
+
params["sort"] = sort
|
|
39
|
+
return params
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
def _has_next(resp: ModelsResponse, page: int) -> bool:
|
|
43
|
+
"""``meta.last_page`` decides; without it, a full page means more may follow (never stop on a short one early)."""
|
|
44
|
+
if not resp.data:
|
|
45
|
+
return False
|
|
46
|
+
last = resp.meta.last_page if resp.meta else None
|
|
47
|
+
if last:
|
|
48
|
+
return page < last
|
|
49
|
+
return len(resp.data) >= MAX_PAGE_SIZE
|
|
50
|
+
|
|
51
|
+
|
|
52
|
+
def _find(models: list[ModelInfo], slug: str) -> ModelInfo | None:
|
|
53
|
+
for m in models:
|
|
54
|
+
if m.slug == slug:
|
|
55
|
+
return m
|
|
56
|
+
return None
|
|
57
|
+
|
|
58
|
+
|
|
59
|
+
class Models:
|
|
60
|
+
"""Sync models listing resource."""
|
|
61
|
+
|
|
62
|
+
def __init__(self, client: SyncHTTPClient) -> None:
|
|
63
|
+
self._client = client
|
|
64
|
+
|
|
65
|
+
def list(
|
|
66
|
+
self,
|
|
67
|
+
*,
|
|
68
|
+
limit: int | None = None,
|
|
69
|
+
page: int = 1,
|
|
70
|
+
inference_types: list[str] | None = None,
|
|
71
|
+
per_page: int | None = None,
|
|
72
|
+
tags: list[str] | None = None,
|
|
73
|
+
sort: str | None = None,
|
|
74
|
+
) -> ModelsResponse:
|
|
75
|
+
"""List one page of available models with optional filtering.
|
|
76
|
+
|
|
77
|
+
``limit`` is the page size (default 50, server cap 50). ``per_page`` is a deprecated alias for ``limit``.
|
|
78
|
+
``tags`` filters by model tag (``new``, ``beta``, ...); ``sort`` is one of ``id``, ``name``,
|
|
79
|
+
``created_at``, ``updated_at``, optionally prefixed with ``-`` (default ``-created_at``).
|
|
80
|
+
Check ``response.meta.last_page`` to know whether more pages exist, or use :meth:`list_all`.
|
|
81
|
+
"""
|
|
82
|
+
url = self._client._resolve_endpoint("models")
|
|
83
|
+
params = _build_params(limit, page, inference_types, per_page, tags, sort)
|
|
84
|
+
resp = self._client.get(url, params=params)
|
|
85
|
+
return ModelsResponse.model_validate(resp)
|
|
86
|
+
|
|
87
|
+
def list_all(
|
|
88
|
+
self,
|
|
89
|
+
*,
|
|
90
|
+
inference_types: builtins.list[str] | None = None,
|
|
91
|
+
tags: builtins.list[str] | None = None,
|
|
92
|
+
sort: str | None = None,
|
|
93
|
+
) -> builtins.list[ModelInfo]:
|
|
94
|
+
"""Fetch every page (limit=50) and return all models."""
|
|
95
|
+
models: list[ModelInfo] = []
|
|
96
|
+
page = 1
|
|
97
|
+
while True:
|
|
98
|
+
resp = self.list(
|
|
99
|
+
limit=MAX_PAGE_SIZE, page=page, inference_types=inference_types,
|
|
100
|
+
tags=tags, sort=sort,
|
|
101
|
+
)
|
|
102
|
+
models.extend(resp.data)
|
|
103
|
+
if not _has_next(resp, page):
|
|
104
|
+
return models
|
|
105
|
+
page += 1
|
|
106
|
+
|
|
107
|
+
def get(self, slug: str) -> ModelInfo | None:
|
|
108
|
+
"""Find a model by slug in the full catalogue, or ``None`` if not available."""
|
|
109
|
+
return _find(self.list_all(), slug)
|
|
110
|
+
|
|
111
|
+
|
|
112
|
+
class AsyncModels:
|
|
113
|
+
"""Async models listing resource."""
|
|
114
|
+
|
|
115
|
+
def __init__(self, client: AsyncHTTPClient) -> None:
|
|
116
|
+
self._client = client
|
|
117
|
+
|
|
118
|
+
async def list(
|
|
119
|
+
self,
|
|
120
|
+
*,
|
|
121
|
+
limit: int | None = None,
|
|
122
|
+
page: int = 1,
|
|
123
|
+
inference_types: list[str] | None = None,
|
|
124
|
+
per_page: int | None = None,
|
|
125
|
+
tags: list[str] | None = None,
|
|
126
|
+
sort: str | None = None,
|
|
127
|
+
) -> ModelsResponse:
|
|
128
|
+
"""List one page of available models with optional filtering.
|
|
129
|
+
|
|
130
|
+
``limit`` is the page size (default 50, server cap 50). ``per_page`` is a deprecated alias for ``limit``.
|
|
131
|
+
``tags`` filters by model tag (``new``, ``beta``, ...); ``sort`` is one of ``id``, ``name``,
|
|
132
|
+
``created_at``, ``updated_at``, optionally prefixed with ``-`` (default ``-created_at``).
|
|
133
|
+
"""
|
|
134
|
+
url = self._client._resolve_endpoint("models")
|
|
135
|
+
params = _build_params(limit, page, inference_types, per_page, tags, sort)
|
|
136
|
+
resp = await self._client.get(url, params=params)
|
|
137
|
+
return ModelsResponse.model_validate(resp)
|
|
138
|
+
|
|
139
|
+
async def list_all(
|
|
140
|
+
self,
|
|
141
|
+
*,
|
|
142
|
+
inference_types: builtins.list[str] | None = None,
|
|
143
|
+
tags: builtins.list[str] | None = None,
|
|
144
|
+
sort: str | None = None,
|
|
145
|
+
) -> builtins.list[ModelInfo]:
|
|
146
|
+
"""Fetch every page (limit=50) and return all models."""
|
|
147
|
+
models: list[ModelInfo] = []
|
|
148
|
+
page = 1
|
|
149
|
+
while True:
|
|
150
|
+
resp = await self.list(
|
|
151
|
+
limit=MAX_PAGE_SIZE, page=page, inference_types=inference_types,
|
|
152
|
+
tags=tags, sort=sort,
|
|
153
|
+
)
|
|
154
|
+
models.extend(resp.data)
|
|
155
|
+
if not _has_next(resp, page):
|
|
156
|
+
return models
|
|
157
|
+
page += 1
|
|
158
|
+
|
|
159
|
+
async def get(self, slug: str) -> ModelInfo | None:
|
|
160
|
+
"""Find a model by slug in the full catalogue, or ``None`` if not available."""
|
|
161
|
+
return _find(await self.list_all(), slug)
|
|
@@ -0,0 +1,152 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
from deapi_sdk._client import AsyncHTTPClient, SyncHTTPClient
|
|
6
|
+
from deapi_sdk._files import FileInput, normalize_file
|
|
7
|
+
from deapi_sdk._payload import form_bool, webhook_fields
|
|
8
|
+
from deapi_sdk._polling import AsyncJob, Job
|
|
9
|
+
from deapi_sdk.types.common import PriceResult
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
class OCR:
|
|
13
|
+
"""Sync image-to-text (OCR) resource."""
|
|
14
|
+
|
|
15
|
+
def __init__(self, client: SyncHTTPClient) -> None:
|
|
16
|
+
self._client = client
|
|
17
|
+
|
|
18
|
+
def extract(
|
|
19
|
+
self,
|
|
20
|
+
*,
|
|
21
|
+
image: FileInput,
|
|
22
|
+
model: str,
|
|
23
|
+
language: str | None = None,
|
|
24
|
+
format: str | None = None,
|
|
25
|
+
return_result_in_response: bool | None = None,
|
|
26
|
+
webhook_url: str | None = None,
|
|
27
|
+
webhook_secret: str | None = None,
|
|
28
|
+
) -> Job:
|
|
29
|
+
"""Submit an image-to-text (OCR) job."""
|
|
30
|
+
url = self._client._resolve_endpoint("img2txt")
|
|
31
|
+
data, files = _build_img2txt_multipart(
|
|
32
|
+
image=image, model=model, language=language, format=format,
|
|
33
|
+
return_result_in_response=return_result_in_response,
|
|
34
|
+
webhook_url=webhook_url, webhook_secret=webhook_secret,
|
|
35
|
+
)
|
|
36
|
+
resp = self._client.post(url, data=data, files=files)
|
|
37
|
+
request_id = resp["data"]["request_id"]
|
|
38
|
+
status_url = self._client._resolve_endpoint("request_status")
|
|
39
|
+
return Job(request_id, self._client, status_url)
|
|
40
|
+
|
|
41
|
+
def extract_price(
|
|
42
|
+
self,
|
|
43
|
+
*,
|
|
44
|
+
model: str,
|
|
45
|
+
image: FileInput | None = None,
|
|
46
|
+
width: int | None = None,
|
|
47
|
+
height: int | None = None,
|
|
48
|
+
language: str | None = None,
|
|
49
|
+
) -> PriceResult:
|
|
50
|
+
"""Calculate price for image-to-text (OCR) -- pass the image, or its width and height."""
|
|
51
|
+
url = self._client._resolve_endpoint("img2txt_price")
|
|
52
|
+
if image is not None:
|
|
53
|
+
data: dict[str, Any] = {"model": model}
|
|
54
|
+
if language is not None:
|
|
55
|
+
data["language"] = language
|
|
56
|
+
files =[("image", normalize_file(image, "image"))]
|
|
57
|
+
resp = self._client.post(url, data=data, files=files)
|
|
58
|
+
else:
|
|
59
|
+
payload: dict[str, Any] = {"model": model}
|
|
60
|
+
if language is not None:
|
|
61
|
+
payload["language"] = language
|
|
62
|
+
if width is not None:
|
|
63
|
+
payload["width"] = width
|
|
64
|
+
if height is not None:
|
|
65
|
+
payload["height"] = height
|
|
66
|
+
resp = self._client.post(url, json=payload)
|
|
67
|
+
return PriceResult.model_validate(resp.get("data", resp))
|
|
68
|
+
|
|
69
|
+
|
|
70
|
+
class AsyncOCR:
|
|
71
|
+
"""Async image-to-text (OCR) resource."""
|
|
72
|
+
|
|
73
|
+
def __init__(self, client: AsyncHTTPClient) -> None:
|
|
74
|
+
self._client = client
|
|
75
|
+
|
|
76
|
+
async def extract(
|
|
77
|
+
self,
|
|
78
|
+
*,
|
|
79
|
+
image: FileInput,
|
|
80
|
+
model: str,
|
|
81
|
+
language: str | None = None,
|
|
82
|
+
format: str | None = None,
|
|
83
|
+
return_result_in_response: bool | None = None,
|
|
84
|
+
webhook_url: str | None = None,
|
|
85
|
+
webhook_secret: str | None = None,
|
|
86
|
+
) -> AsyncJob:
|
|
87
|
+
"""Submit an image-to-text (OCR) job."""
|
|
88
|
+
url = self._client._resolve_endpoint("img2txt")
|
|
89
|
+
data, files = _build_img2txt_multipart(
|
|
90
|
+
image=image, model=model, language=language, format=format,
|
|
91
|
+
return_result_in_response=return_result_in_response,
|
|
92
|
+
webhook_url=webhook_url, webhook_secret=webhook_secret,
|
|
93
|
+
)
|
|
94
|
+
resp = await self._client.post(url, data=data, files=files)
|
|
95
|
+
request_id = resp["data"]["request_id"]
|
|
96
|
+
status_url = self._client._resolve_endpoint("request_status")
|
|
97
|
+
return AsyncJob(request_id, self._client, status_url)
|
|
98
|
+
|
|
99
|
+
async def extract_price(
|
|
100
|
+
self,
|
|
101
|
+
*,
|
|
102
|
+
model: str,
|
|
103
|
+
image: FileInput | None = None,
|
|
104
|
+
width: int | None = None,
|
|
105
|
+
height: int | None = None,
|
|
106
|
+
language: str | None = None,
|
|
107
|
+
) -> PriceResult:
|
|
108
|
+
"""Calculate price for image-to-text (OCR) -- pass the image, or its width and height."""
|
|
109
|
+
url = self._client._resolve_endpoint("img2txt_price")
|
|
110
|
+
if image is not None:
|
|
111
|
+
data: dict[str, Any] = {"model": model}
|
|
112
|
+
if language is not None:
|
|
113
|
+
data["language"] = language
|
|
114
|
+
files =[("image", normalize_file(image, "image"))]
|
|
115
|
+
resp = await self._client.post(url, data=data, files=files)
|
|
116
|
+
else:
|
|
117
|
+
payload: dict[str, Any] = {"model": model}
|
|
118
|
+
if language is not None:
|
|
119
|
+
payload["language"] = language
|
|
120
|
+
if width is not None:
|
|
121
|
+
payload["width"] = width
|
|
122
|
+
if height is not None:
|
|
123
|
+
payload["height"] = height
|
|
124
|
+
resp = await self._client.post(url, json=payload)
|
|
125
|
+
return PriceResult.model_validate(resp.get("data", resp))
|
|
126
|
+
|
|
127
|
+
|
|
128
|
+
# --- Private helpers ---
|
|
129
|
+
|
|
130
|
+
def _build_img2txt_multipart(
|
|
131
|
+
*,
|
|
132
|
+
image: FileInput,
|
|
133
|
+
model: str,
|
|
134
|
+
language: str | None = None,
|
|
135
|
+
format: str | None = None,
|
|
136
|
+
return_result_in_response: bool | None = None,
|
|
137
|
+
webhook_url: str | None = None,
|
|
138
|
+
webhook_secret: str | None = None,
|
|
139
|
+
) -> tuple[dict[str, Any], list[tuple[str, tuple[str, bytes, str]]]]:
|
|
140
|
+
"""Build multipart form data and files list for img2txt."""
|
|
141
|
+
webhook = webhook_fields(webhook_url, webhook_secret)
|
|
142
|
+
data: dict[str, Any] = {"model": model}
|
|
143
|
+
if language is not None:
|
|
144
|
+
data["language"] = language
|
|
145
|
+
if format is not None:
|
|
146
|
+
data["format"] = format
|
|
147
|
+
if return_result_in_response is not None:
|
|
148
|
+
data["return_result_in_response"] = form_bool(return_result_in_response)
|
|
149
|
+
data.update(webhook)
|
|
150
|
+
|
|
151
|
+
files = [("image", normalize_file(image, "image"))]
|
|
152
|
+
return data, files
|