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.
Files changed (47) hide show
  1. deapi_sdk/__init__.py +409 -0
  2. deapi_sdk/_cards.py +313 -0
  3. deapi_sdk/_client.py +411 -0
  4. deapi_sdk/_config.py +77 -0
  5. deapi_sdk/_constants.py +61 -0
  6. deapi_sdk/_download.py +37 -0
  7. deapi_sdk/_exceptions.py +184 -0
  8. deapi_sdk/_files.py +59 -0
  9. deapi_sdk/_payload.py +50 -0
  10. deapi_sdk/_polling.py +157 -0
  11. deapi_sdk/_realtime/__init__.py +7 -0
  12. deapi_sdk/_realtime/_discovery.py +43 -0
  13. deapi_sdk/_realtime/_engine.py +419 -0
  14. deapi_sdk/_realtime/_protocol.py +152 -0
  15. deapi_sdk/_realtime/_session.py +529 -0
  16. deapi_sdk/_types.py +31 -0
  17. deapi_sdk/_version.py +3 -0
  18. deapi_sdk/py.typed +0 -0
  19. deapi_sdk/resources/__init__.py +35 -0
  20. deapi_sdk/resources/account.py +149 -0
  21. deapi_sdk/resources/audio.py +386 -0
  22. deapi_sdk/resources/embeddings.py +116 -0
  23. deapi_sdk/resources/images.py +616 -0
  24. deapi_sdk/resources/keys.py +277 -0
  25. deapi_sdk/resources/models.py +161 -0
  26. deapi_sdk/resources/ocr.py +152 -0
  27. deapi_sdk/resources/prompts.py +137 -0
  28. deapi_sdk/resources/transcription.py +308 -0
  29. deapi_sdk/resources/video.py +985 -0
  30. deapi_sdk/transcript.py +142 -0
  31. deapi_sdk/types/__init__.py +68 -0
  32. deapi_sdk/types/account.py +115 -0
  33. deapi_sdk/types/audio.py +35 -0
  34. deapi_sdk/types/common.py +174 -0
  35. deapi_sdk/types/embeddings.py +11 -0
  36. deapi_sdk/types/images.py +40 -0
  37. deapi_sdk/types/keys.py +53 -0
  38. deapi_sdk/types/ocr.py +14 -0
  39. deapi_sdk/types/prompts.py +26 -0
  40. deapi_sdk/types/transcription.py +14 -0
  41. deapi_sdk/types/video.py +84 -0
  42. deapi_sdk/types/websocket.py +36 -0
  43. deapi_sdk/webhook.py +159 -0
  44. deapi_sdk-0.6.1.dist-info/METADATA +644 -0
  45. deapi_sdk-0.6.1.dist-info/RECORD +47 -0
  46. deapi_sdk-0.6.1.dist-info/WHEEL +4 -0
  47. 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