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,149 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from datetime import date, datetime
|
|
4
|
+
from typing import Any
|
|
5
|
+
|
|
6
|
+
from deapi_sdk._client import AsyncHTTPClient, SyncHTTPClient
|
|
7
|
+
from deapi_sdk.types.account import Account, PaymentsPage, UsageReport
|
|
8
|
+
from deapi_sdk.types.common import Balance
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
def _fmt_time(value: str | date | datetime | None) -> str | None:
|
|
12
|
+
if value is None:
|
|
13
|
+
return None
|
|
14
|
+
if isinstance(value, (datetime, date)):
|
|
15
|
+
return value.isoformat()
|
|
16
|
+
return value
|
|
17
|
+
|
|
18
|
+
|
|
19
|
+
def usage_params(
|
|
20
|
+
from_: str | date | datetime | None,
|
|
21
|
+
to: str | date | datetime | None,
|
|
22
|
+
group_by: str | None,
|
|
23
|
+
extra: dict[str, Any],
|
|
24
|
+
) -> dict[str, Any]:
|
|
25
|
+
params: dict[str, Any] = dict(extra)
|
|
26
|
+
if from_ is not None:
|
|
27
|
+
params["from"] = _fmt_time(from_)
|
|
28
|
+
if to is not None:
|
|
29
|
+
params["to"] = _fmt_time(to)
|
|
30
|
+
if group_by is not None:
|
|
31
|
+
params["group_by"] = group_by
|
|
32
|
+
return params
|
|
33
|
+
|
|
34
|
+
|
|
35
|
+
def page_params(
|
|
36
|
+
limit: int | None, page: int | None, per_page: int | None, extra: dict[str, Any]
|
|
37
|
+
) -> dict[str, Any] | None:
|
|
38
|
+
params: dict[str, Any] = dict(extra)
|
|
39
|
+
if limit is not None:
|
|
40
|
+
params["limit"] = limit
|
|
41
|
+
if page is not None:
|
|
42
|
+
params["page"] = page
|
|
43
|
+
if per_page is not None:
|
|
44
|
+
params["per_page"] = per_page
|
|
45
|
+
return params or None
|
|
46
|
+
|
|
47
|
+
|
|
48
|
+
def unwrap(resp: Any) -> Any:
|
|
49
|
+
return resp.get("data", resp) if isinstance(resp, dict) else resp
|
|
50
|
+
|
|
51
|
+
|
|
52
|
+
def parse_usage(resp: Any) -> UsageReport:
|
|
53
|
+
data = unwrap(resp)
|
|
54
|
+
if isinstance(data, list): # defensive: a bare list of groups
|
|
55
|
+
return UsageReport.model_validate({"groups": data})
|
|
56
|
+
return UsageReport.model_validate(data)
|
|
57
|
+
|
|
58
|
+
|
|
59
|
+
class AccountResource:
|
|
60
|
+
"""Account billing and usage (API v2). Every call needs an ADMIN key (API keys get 403)."""
|
|
61
|
+
|
|
62
|
+
def __init__(self, client: SyncHTTPClient) -> None:
|
|
63
|
+
self._client = client
|
|
64
|
+
|
|
65
|
+
def get(self) -> Account:
|
|
66
|
+
"""Balance, currency and auto top-up settings (``GET /account``). ADMIN key only."""
|
|
67
|
+
resp = self._client.get(self._client._resolve_endpoint("account"))
|
|
68
|
+
return Account.model_validate(unwrap(resp))
|
|
69
|
+
|
|
70
|
+
def balance(self) -> Balance:
|
|
71
|
+
"""Current balance (``GET /account/balance``). ADMIN key only."""
|
|
72
|
+
resp = self._client.get(self._client._resolve_endpoint("balance"))
|
|
73
|
+
return Balance.model_validate(unwrap(resp))
|
|
74
|
+
|
|
75
|
+
def usage(
|
|
76
|
+
self,
|
|
77
|
+
*,
|
|
78
|
+
from_: str | date | datetime | None = None,
|
|
79
|
+
to: str | date | datetime | None = None,
|
|
80
|
+
group_by: str | None = None,
|
|
81
|
+
**params: Any,
|
|
82
|
+
) -> UsageReport:
|
|
83
|
+
"""Usage of the whole account (``GET /account/usage``). ADMIN key only.
|
|
84
|
+
|
|
85
|
+
``group_by`` is one of ``day``, ``hour``, ``key``, ``type``, ``model``.
|
|
86
|
+
"""
|
|
87
|
+
url = self._client._resolve_endpoint("account_usage")
|
|
88
|
+
return parse_usage(self._client.get(url, params=usage_params(from_, to, group_by, params)))
|
|
89
|
+
|
|
90
|
+
def payments(
|
|
91
|
+
self,
|
|
92
|
+
*,
|
|
93
|
+
limit: int | None = None,
|
|
94
|
+
page: int | None = None,
|
|
95
|
+
per_page: int | None = None,
|
|
96
|
+
**params: Any,
|
|
97
|
+
) -> PaymentsPage:
|
|
98
|
+
"""One page of balance top-ups (``GET /account/payments``). ADMIN key only.
|
|
99
|
+
|
|
100
|
+
``limit`` is the page size (default 50, max 100; ``per_page`` is an alias, ``limit`` wins).
|
|
101
|
+
Items carry ``id``, ``amount``, ``currency``, ``status``, ``provider`` and ``created_at``.
|
|
102
|
+
"""
|
|
103
|
+
resp = self._client.get(
|
|
104
|
+
self._client._resolve_endpoint("account_payments"), params=page_params(limit, page, per_page, params)
|
|
105
|
+
)
|
|
106
|
+
return PaymentsPage.model_validate(resp)
|
|
107
|
+
|
|
108
|
+
|
|
109
|
+
class AsyncAccountResource:
|
|
110
|
+
"""Async variant of :class:`AccountResource`. Every call needs an ADMIN key."""
|
|
111
|
+
|
|
112
|
+
def __init__(self, client: AsyncHTTPClient) -> None:
|
|
113
|
+
self._client = client
|
|
114
|
+
|
|
115
|
+
async def get(self) -> Account:
|
|
116
|
+
"""Balance, currency and auto top-up settings (``GET /account``). ADMIN key only."""
|
|
117
|
+
resp = await self._client.get(self._client._resolve_endpoint("account"))
|
|
118
|
+
return Account.model_validate(unwrap(resp))
|
|
119
|
+
|
|
120
|
+
async def balance(self) -> Balance:
|
|
121
|
+
"""Current balance (``GET /account/balance``). ADMIN key only."""
|
|
122
|
+
resp = await self._client.get(self._client._resolve_endpoint("balance"))
|
|
123
|
+
return Balance.model_validate(unwrap(resp))
|
|
124
|
+
|
|
125
|
+
async def usage(
|
|
126
|
+
self,
|
|
127
|
+
*,
|
|
128
|
+
from_: str | date | datetime | None = None,
|
|
129
|
+
to: str | date | datetime | None = None,
|
|
130
|
+
group_by: str | None = None,
|
|
131
|
+
**params: Any,
|
|
132
|
+
) -> UsageReport:
|
|
133
|
+
"""Usage of the whole account (``GET /account/usage``). ADMIN key only."""
|
|
134
|
+
url = self._client._resolve_endpoint("account_usage")
|
|
135
|
+
return parse_usage(await self._client.get(url, params=usage_params(from_, to, group_by, params)))
|
|
136
|
+
|
|
137
|
+
async def payments(
|
|
138
|
+
self,
|
|
139
|
+
*,
|
|
140
|
+
limit: int | None = None,
|
|
141
|
+
page: int | None = None,
|
|
142
|
+
per_page: int | None = None,
|
|
143
|
+
**params: Any,
|
|
144
|
+
) -> PaymentsPage:
|
|
145
|
+
"""One page of balance top-ups (``GET /account/payments``). ADMIN key only. See the sync variant."""
|
|
146
|
+
resp = await self._client.get(
|
|
147
|
+
self._client._resolve_endpoint("account_payments"), params=page_params(limit, page, per_page, params)
|
|
148
|
+
)
|
|
149
|
+
return PaymentsPage.model_validate(resp)
|
|
@@ -0,0 +1,386 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
from deapi_sdk._cards import MUSIC_KEYS, MUSIC_PRICE_KEYS, TTS_KEYS, afill_payload, fill_payload
|
|
6
|
+
from deapi_sdk._client import AsyncHTTPClient, SyncHTTPClient
|
|
7
|
+
from deapi_sdk._files import FileInput, normalize_file
|
|
8
|
+
from deapi_sdk._payload import drop_none, webhook_fields
|
|
9
|
+
from deapi_sdk._polling import AsyncJob, Job
|
|
10
|
+
from deapi_sdk.types.common import PriceResult
|
|
11
|
+
|
|
12
|
+
|
|
13
|
+
class Audio:
|
|
14
|
+
"""Sync audio resource -- TTS and music generation."""
|
|
15
|
+
|
|
16
|
+
def __init__(self, client: SyncHTTPClient) -> None:
|
|
17
|
+
self._client = client
|
|
18
|
+
|
|
19
|
+
def synthesize(
|
|
20
|
+
self,
|
|
21
|
+
*,
|
|
22
|
+
text: str,
|
|
23
|
+
model: str,
|
|
24
|
+
lang: str | None = None,
|
|
25
|
+
format: str | None = None,
|
|
26
|
+
speed: float | None = None,
|
|
27
|
+
sample_rate: float | None = None,
|
|
28
|
+
mode: str | None = None,
|
|
29
|
+
voice: str | None = None,
|
|
30
|
+
ref_audio: FileInput | None = None,
|
|
31
|
+
ref_text: str | None = None,
|
|
32
|
+
instruct: str | None = None,
|
|
33
|
+
webhook_url: str | None = None,
|
|
34
|
+
webhook_secret: str | None = None,
|
|
35
|
+
) -> Job:
|
|
36
|
+
"""Submit a text-to-audio (TTS) job.
|
|
37
|
+
|
|
38
|
+
Unset ``lang``, ``format``, ``speed`` and ``sample_rate`` are taken from the model's
|
|
39
|
+
``info.defaults`` (one catalogue request per client, cached; disable with ``fill_model_defaults=False``).
|
|
40
|
+
``ref_audio`` makes the request multipart.
|
|
41
|
+
"""
|
|
42
|
+
url = self._client._resolve_endpoint("txt2audio")
|
|
43
|
+
data, files = _build_tts_multipart(
|
|
44
|
+
text=text, model=model, lang=lang, format=format, speed=speed,
|
|
45
|
+
sample_rate=sample_rate, mode=mode, voice=voice, ref_audio=ref_audio,
|
|
46
|
+
ref_text=ref_text, instruct=instruct,
|
|
47
|
+
webhook_url=webhook_url, webhook_secret=webhook_secret,
|
|
48
|
+
)
|
|
49
|
+
data = fill_payload(self._client, data, TTS_KEYS, form=bool(files), tts=True)
|
|
50
|
+
resp = self._client.post(url, data=data, files=files) if files else self._client.post(url, json=data)
|
|
51
|
+
request_id = resp["data"]["request_id"]
|
|
52
|
+
status_url = self._client._resolve_endpoint("request_status")
|
|
53
|
+
return Job(request_id, self._client, status_url)
|
|
54
|
+
|
|
55
|
+
def synthesize_price(
|
|
56
|
+
self,
|
|
57
|
+
*,
|
|
58
|
+
model: str,
|
|
59
|
+
lang: str | None = None,
|
|
60
|
+
format: str | None = None,
|
|
61
|
+
speed: float | None = None,
|
|
62
|
+
sample_rate: float | None = None,
|
|
63
|
+
text: str | None = None,
|
|
64
|
+
count_text: int | None = None,
|
|
65
|
+
mode: str | None = None,
|
|
66
|
+
voice: str | None = None,
|
|
67
|
+
instruct: str | None = None,
|
|
68
|
+
) -> PriceResult:
|
|
69
|
+
"""Calculate price for TTS (pass ``text`` or ``count_text``).
|
|
70
|
+
|
|
71
|
+
Unset ``lang``, ``format``, ``speed`` and ``sample_rate`` are taken from the model's
|
|
72
|
+
``info.defaults`` (one catalogue request per
|
|
73
|
+
client, cached; disable with ``fill_model_defaults=False``).
|
|
74
|
+
"""
|
|
75
|
+
url = self._client._resolve_endpoint("txt2audio_price")
|
|
76
|
+
payload = drop_none({
|
|
77
|
+
"model": model, "lang": lang, "format": format, "speed": speed,
|
|
78
|
+
"sample_rate": sample_rate, "text": text, "count_text": count_text,
|
|
79
|
+
"mode": mode, "voice": voice, "instruct": instruct,
|
|
80
|
+
})
|
|
81
|
+
payload = fill_payload(self._client, payload, TTS_KEYS, tts=True)
|
|
82
|
+
resp = self._client.post(url, json=payload)
|
|
83
|
+
return PriceResult.model_validate(resp.get("data", resp))
|
|
84
|
+
|
|
85
|
+
def compose(
|
|
86
|
+
self,
|
|
87
|
+
*,
|
|
88
|
+
caption: str,
|
|
89
|
+
model: str,
|
|
90
|
+
duration: float,
|
|
91
|
+
inference_steps: int | None = None,
|
|
92
|
+
guidance_scale: float | None = None,
|
|
93
|
+
seed: int | None = None,
|
|
94
|
+
format: str | None = None,
|
|
95
|
+
lyrics: str | None = None,
|
|
96
|
+
bpm: int | None = None,
|
|
97
|
+
keyscale: str | None = None,
|
|
98
|
+
timesignature: int | None = None,
|
|
99
|
+
vocal_language: str | None = None,
|
|
100
|
+
reference_audio: FileInput | None = None,
|
|
101
|
+
webhook_url: str | None = None,
|
|
102
|
+
webhook_secret: str | None = None,
|
|
103
|
+
) -> Job:
|
|
104
|
+
"""Submit a text-to-music generation job.
|
|
105
|
+
|
|
106
|
+
``reference_audio`` (style reference, length within the model's window) turns the
|
|
107
|
+
request into multipart/form-data; without it the request is JSON. The API requires
|
|
108
|
+
non-empty ``lyrics`` (use ``"[Instrumental]"`` for instrumentals) and an integer
|
|
109
|
+
``timesignature`` (2, 3, 4 or 6).
|
|
110
|
+
|
|
111
|
+
Unset ``format``, ``inference_steps`` and ``guidance_scale`` are taken from the model's
|
|
112
|
+
``info.defaults`` (one catalogue request per
|
|
113
|
+
client, cached; disable with ``fill_model_defaults=False``); ``seed`` defaults to -1 (random).
|
|
114
|
+
"""
|
|
115
|
+
url = self._client._resolve_endpoint("txt2music")
|
|
116
|
+
payload, files = _build_music_request(
|
|
117
|
+
caption=caption, model=model, duration=duration,
|
|
118
|
+
inference_steps=inference_steps, guidance_scale=guidance_scale,
|
|
119
|
+
seed=seed, format=format, lyrics=lyrics, bpm=bpm,
|
|
120
|
+
keyscale=keyscale, timesignature=timesignature,
|
|
121
|
+
vocal_language=vocal_language, reference_audio=reference_audio,
|
|
122
|
+
webhook_url=webhook_url, webhook_secret=webhook_secret,
|
|
123
|
+
)
|
|
124
|
+
payload = fill_payload(self._client, payload, MUSIC_KEYS, seed=True, form=bool(files))
|
|
125
|
+
resp = self._client.post(url, data=payload, files=files) if files else self._client.post(url, json=payload)
|
|
126
|
+
request_id = resp["data"]["request_id"]
|
|
127
|
+
status_url = self._client._resolve_endpoint("request_status")
|
|
128
|
+
return Job(request_id, self._client, status_url)
|
|
129
|
+
|
|
130
|
+
def compose_price(
|
|
131
|
+
self,
|
|
132
|
+
*,
|
|
133
|
+
model: str,
|
|
134
|
+
duration: float,
|
|
135
|
+
inference_steps: int | None = None,
|
|
136
|
+
guidance_scale: float | None = None,
|
|
137
|
+
caption: str | None = None,
|
|
138
|
+
lyrics: str | None = None,
|
|
139
|
+
bpm: int | None = None,
|
|
140
|
+
keyscale: str | None = None,
|
|
141
|
+
timesignature: int | None = None,
|
|
142
|
+
vocal_language: str | None = None,
|
|
143
|
+
) -> PriceResult:
|
|
144
|
+
"""Calculate price for music generation (only model, duration and steps affect the price).
|
|
145
|
+
|
|
146
|
+
Unset ``inference_steps`` are taken from the model's ``info.defaults`` (one catalogue request per
|
|
147
|
+
client, cached; disable with ``fill_model_defaults=False``).
|
|
148
|
+
"""
|
|
149
|
+
url = self._client._resolve_endpoint("txt2music_price")
|
|
150
|
+
payload = drop_none({
|
|
151
|
+
"model": model, "duration": duration, "inference_steps": inference_steps,
|
|
152
|
+
"guidance_scale": guidance_scale, "caption": caption, "lyrics": lyrics,
|
|
153
|
+
"bpm": bpm, "keyscale": keyscale, "timesignature": timesignature,
|
|
154
|
+
"vocal_language": vocal_language,
|
|
155
|
+
})
|
|
156
|
+
payload = fill_payload(self._client, payload, MUSIC_PRICE_KEYS)
|
|
157
|
+
resp = self._client.post(url, json=payload)
|
|
158
|
+
return PriceResult.model_validate(resp.get("data", resp))
|
|
159
|
+
|
|
160
|
+
|
|
161
|
+
class AsyncAudio:
|
|
162
|
+
"""Async audio resource -- TTS and music generation."""
|
|
163
|
+
|
|
164
|
+
def __init__(self, client: AsyncHTTPClient) -> None:
|
|
165
|
+
self._client = client
|
|
166
|
+
|
|
167
|
+
async def synthesize(
|
|
168
|
+
self,
|
|
169
|
+
*,
|
|
170
|
+
text: str,
|
|
171
|
+
model: str,
|
|
172
|
+
lang: str | None = None,
|
|
173
|
+
format: str | None = None,
|
|
174
|
+
speed: float | None = None,
|
|
175
|
+
sample_rate: float | None = None,
|
|
176
|
+
mode: str | None = None,
|
|
177
|
+
voice: str | None = None,
|
|
178
|
+
ref_audio: FileInput | None = None,
|
|
179
|
+
ref_text: str | None = None,
|
|
180
|
+
instruct: str | None = None,
|
|
181
|
+
webhook_url: str | None = None,
|
|
182
|
+
webhook_secret: str | None = None,
|
|
183
|
+
) -> AsyncJob:
|
|
184
|
+
"""Submit a text-to-audio (TTS) job.
|
|
185
|
+
|
|
186
|
+
Unset ``lang``, ``format``, ``speed`` and ``sample_rate`` are taken from the model's
|
|
187
|
+
``info.defaults`` (one catalogue request per client, cached; disable with ``fill_model_defaults=False``).
|
|
188
|
+
``ref_audio`` makes the request multipart.
|
|
189
|
+
"""
|
|
190
|
+
url = self._client._resolve_endpoint("txt2audio")
|
|
191
|
+
data, files = _build_tts_multipart(
|
|
192
|
+
text=text, model=model, lang=lang, format=format, speed=speed,
|
|
193
|
+
sample_rate=sample_rate, mode=mode, voice=voice, ref_audio=ref_audio,
|
|
194
|
+
ref_text=ref_text, instruct=instruct,
|
|
195
|
+
webhook_url=webhook_url, webhook_secret=webhook_secret,
|
|
196
|
+
)
|
|
197
|
+
data = await afill_payload(self._client, data, TTS_KEYS, form=bool(files), tts=True)
|
|
198
|
+
if files:
|
|
199
|
+
resp = await self._client.post(url, data=data, files=files)
|
|
200
|
+
else:
|
|
201
|
+
resp = await self._client.post(url, json=data)
|
|
202
|
+
request_id = resp["data"]["request_id"]
|
|
203
|
+
status_url = self._client._resolve_endpoint("request_status")
|
|
204
|
+
return AsyncJob(request_id, self._client, status_url)
|
|
205
|
+
|
|
206
|
+
async def synthesize_price(
|
|
207
|
+
self,
|
|
208
|
+
*,
|
|
209
|
+
model: str,
|
|
210
|
+
lang: str | None = None,
|
|
211
|
+
format: str | None = None,
|
|
212
|
+
speed: float | None = None,
|
|
213
|
+
sample_rate: float | None = None,
|
|
214
|
+
text: str | None = None,
|
|
215
|
+
count_text: int | None = None,
|
|
216
|
+
mode: str | None = None,
|
|
217
|
+
voice: str | None = None,
|
|
218
|
+
instruct: str | None = None,
|
|
219
|
+
) -> PriceResult:
|
|
220
|
+
"""Calculate price for TTS (pass ``text`` or ``count_text``).
|
|
221
|
+
|
|
222
|
+
Unset ``lang``, ``format``, ``speed`` and ``sample_rate`` are taken from the model's
|
|
223
|
+
``info.defaults`` (one catalogue request per
|
|
224
|
+
client, cached; disable with ``fill_model_defaults=False``).
|
|
225
|
+
"""
|
|
226
|
+
url = self._client._resolve_endpoint("txt2audio_price")
|
|
227
|
+
payload = drop_none({
|
|
228
|
+
"model": model, "lang": lang, "format": format, "speed": speed,
|
|
229
|
+
"sample_rate": sample_rate, "text": text, "count_text": count_text,
|
|
230
|
+
"mode": mode, "voice": voice, "instruct": instruct,
|
|
231
|
+
})
|
|
232
|
+
payload = await afill_payload(self._client, payload, TTS_KEYS, tts=True)
|
|
233
|
+
resp = await self._client.post(url, json=payload)
|
|
234
|
+
return PriceResult.model_validate(resp.get("data", resp))
|
|
235
|
+
|
|
236
|
+
async def compose(
|
|
237
|
+
self,
|
|
238
|
+
*,
|
|
239
|
+
caption: str,
|
|
240
|
+
model: str,
|
|
241
|
+
duration: float,
|
|
242
|
+
inference_steps: int | None = None,
|
|
243
|
+
guidance_scale: float | None = None,
|
|
244
|
+
seed: int | None = None,
|
|
245
|
+
format: str | None = None,
|
|
246
|
+
lyrics: str | None = None,
|
|
247
|
+
bpm: int | None = None,
|
|
248
|
+
keyscale: str | None = None,
|
|
249
|
+
timesignature: int | None = None,
|
|
250
|
+
vocal_language: str | None = None,
|
|
251
|
+
reference_audio: FileInput | None = None,
|
|
252
|
+
webhook_url: str | None = None,
|
|
253
|
+
webhook_secret: str | None = None,
|
|
254
|
+
) -> AsyncJob:
|
|
255
|
+
"""Submit a text-to-music generation job.
|
|
256
|
+
|
|
257
|
+
``reference_audio`` (style reference, length within the model's window) turns the
|
|
258
|
+
request into multipart/form-data; without it the request is JSON. The API requires
|
|
259
|
+
non-empty ``lyrics`` (use ``"[Instrumental]"`` for instrumentals) and an integer
|
|
260
|
+
``timesignature`` (2, 3, 4 or 6).
|
|
261
|
+
|
|
262
|
+
Unset ``format``, ``inference_steps`` and ``guidance_scale`` are taken from the model's
|
|
263
|
+
``info.defaults`` (one catalogue request per
|
|
264
|
+
client, cached; disable with ``fill_model_defaults=False``); ``seed`` defaults to -1 (random).
|
|
265
|
+
"""
|
|
266
|
+
url = self._client._resolve_endpoint("txt2music")
|
|
267
|
+
payload, files = _build_music_request(
|
|
268
|
+
caption=caption, model=model, duration=duration,
|
|
269
|
+
inference_steps=inference_steps, guidance_scale=guidance_scale,
|
|
270
|
+
seed=seed, format=format, lyrics=lyrics, bpm=bpm,
|
|
271
|
+
keyscale=keyscale, timesignature=timesignature,
|
|
272
|
+
vocal_language=vocal_language, reference_audio=reference_audio,
|
|
273
|
+
webhook_url=webhook_url, webhook_secret=webhook_secret,
|
|
274
|
+
)
|
|
275
|
+
payload = await afill_payload(self._client, payload, MUSIC_KEYS, seed=True, form=bool(files))
|
|
276
|
+
if files:
|
|
277
|
+
resp = await self._client.post(url, data=payload, files=files)
|
|
278
|
+
else:
|
|
279
|
+
resp = await self._client.post(url, json=payload)
|
|
280
|
+
request_id = resp["data"]["request_id"]
|
|
281
|
+
status_url = self._client._resolve_endpoint("request_status")
|
|
282
|
+
return AsyncJob(request_id, self._client, status_url)
|
|
283
|
+
|
|
284
|
+
async def compose_price(
|
|
285
|
+
self,
|
|
286
|
+
*,
|
|
287
|
+
model: str,
|
|
288
|
+
duration: float,
|
|
289
|
+
inference_steps: int | None = None,
|
|
290
|
+
guidance_scale: float | None = None,
|
|
291
|
+
caption: str | None = None,
|
|
292
|
+
lyrics: str | None = None,
|
|
293
|
+
bpm: int | None = None,
|
|
294
|
+
keyscale: str | None = None,
|
|
295
|
+
timesignature: int | None = None,
|
|
296
|
+
vocal_language: str | None = None,
|
|
297
|
+
) -> PriceResult:
|
|
298
|
+
"""Calculate price for music generation (only model, duration and steps affect the price).
|
|
299
|
+
|
|
300
|
+
Unset ``inference_steps`` are taken from the model's ``info.defaults`` (one catalogue request per
|
|
301
|
+
client, cached; disable with ``fill_model_defaults=False``).
|
|
302
|
+
"""
|
|
303
|
+
url = self._client._resolve_endpoint("txt2music_price")
|
|
304
|
+
payload = drop_none({
|
|
305
|
+
"model": model, "duration": duration, "inference_steps": inference_steps,
|
|
306
|
+
"guidance_scale": guidance_scale, "caption": caption, "lyrics": lyrics,
|
|
307
|
+
"bpm": bpm, "keyscale": keyscale, "timesignature": timesignature,
|
|
308
|
+
"vocal_language": vocal_language,
|
|
309
|
+
})
|
|
310
|
+
payload = await afill_payload(self._client, payload, MUSIC_PRICE_KEYS)
|
|
311
|
+
resp = await self._client.post(url, json=payload)
|
|
312
|
+
return PriceResult.model_validate(resp.get("data", resp))
|
|
313
|
+
|
|
314
|
+
|
|
315
|
+
# --- Private helpers ---
|
|
316
|
+
|
|
317
|
+
def _build_tts_multipart(
|
|
318
|
+
*,
|
|
319
|
+
text: str,
|
|
320
|
+
model: str,
|
|
321
|
+
lang: str | None = None,
|
|
322
|
+
format: str | None = None,
|
|
323
|
+
speed: float | None = None,
|
|
324
|
+
sample_rate: float | None = None,
|
|
325
|
+
mode: str | None = None,
|
|
326
|
+
voice: str | None = None,
|
|
327
|
+
ref_audio: FileInput | None = None,
|
|
328
|
+
ref_text: str | None = None,
|
|
329
|
+
instruct: str | None = None,
|
|
330
|
+
webhook_url: str | None = None,
|
|
331
|
+
webhook_secret: str | None = None,
|
|
332
|
+
) -> tuple[dict[str, Any], list[tuple[str, tuple[str, bytes, str]]]]:
|
|
333
|
+
"""Build form data for TTS. Returns (data_dict, file_tuples).
|
|
334
|
+
|
|
335
|
+
When ref_audio is provided, the request must be multipart/form-data.
|
|
336
|
+
Otherwise, the caller should send as JSON.
|
|
337
|
+
"""
|
|
338
|
+
webhook = webhook_fields(webhook_url, webhook_secret)
|
|
339
|
+
data = drop_none({
|
|
340
|
+
"text": text, "model": model, "lang": lang, "format": format,
|
|
341
|
+
"speed": speed, "sample_rate": sample_rate, "mode": mode, "voice": voice,
|
|
342
|
+
"ref_text": ref_text, "instruct": instruct,
|
|
343
|
+
})
|
|
344
|
+
data.update(webhook)
|
|
345
|
+
|
|
346
|
+
file_tuples: list[tuple[str, tuple[str, bytes, str]]] = []
|
|
347
|
+
if ref_audio is not None:
|
|
348
|
+
normalized = normalize_file(ref_audio, "ref_audio")
|
|
349
|
+
file_tuples.append(("ref_audio", normalized))
|
|
350
|
+
|
|
351
|
+
return data, file_tuples
|
|
352
|
+
|
|
353
|
+
|
|
354
|
+
def _build_music_request(
|
|
355
|
+
*,
|
|
356
|
+
caption: str,
|
|
357
|
+
model: str,
|
|
358
|
+
duration: float,
|
|
359
|
+
inference_steps: int | None = None,
|
|
360
|
+
guidance_scale: float | None = None,
|
|
361
|
+
seed: int | None = None,
|
|
362
|
+
format: str | None = None,
|
|
363
|
+
lyrics: str | None = None,
|
|
364
|
+
bpm: int | None = None,
|
|
365
|
+
keyscale: str | None = None,
|
|
366
|
+
timesignature: int | None = None,
|
|
367
|
+
vocal_language: str | None = None,
|
|
368
|
+
reference_audio: FileInput | None = None,
|
|
369
|
+
webhook_url: str | None = None,
|
|
370
|
+
webhook_secret: str | None = None,
|
|
371
|
+
) -> tuple[dict[str, Any], list[tuple[str, tuple[str, bytes, str]]]]:
|
|
372
|
+
"""Build the music request body. Returns (fields, files); files is non-empty -> multipart."""
|
|
373
|
+
webhook = webhook_fields(webhook_url, webhook_secret)
|
|
374
|
+
payload = drop_none({
|
|
375
|
+
"caption": caption, "model": model, "duration": duration,
|
|
376
|
+
"inference_steps": inference_steps, "guidance_scale": guidance_scale,
|
|
377
|
+
"seed": seed, "format": format, "lyrics": lyrics, "bpm": bpm,
|
|
378
|
+
"keyscale": keyscale, "timesignature": timesignature,
|
|
379
|
+
"vocal_language": vocal_language,
|
|
380
|
+
})
|
|
381
|
+
payload.update(webhook)
|
|
382
|
+
|
|
383
|
+
file_tuples: list[tuple[str, tuple[str, bytes, str]]] = []
|
|
384
|
+
if reference_audio is not None:
|
|
385
|
+
file_tuples.append(("reference_audio", normalize_file(reference_audio, "reference_audio")))
|
|
386
|
+
return payload, file_tuples
|
|
@@ -0,0 +1,116 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
from deapi_sdk._client import AsyncHTTPClient, SyncHTTPClient
|
|
6
|
+
from deapi_sdk._payload import webhook_fields
|
|
7
|
+
from deapi_sdk._polling import AsyncJob, Job
|
|
8
|
+
from deapi_sdk.types.common import PriceResult
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
class Embeddings:
|
|
12
|
+
"""Sync embeddings resource."""
|
|
13
|
+
|
|
14
|
+
def __init__(self, client: SyncHTTPClient) -> None:
|
|
15
|
+
self._client = client
|
|
16
|
+
|
|
17
|
+
def create(
|
|
18
|
+
self,
|
|
19
|
+
*,
|
|
20
|
+
input: str | list[str],
|
|
21
|
+
model: str,
|
|
22
|
+
return_result_in_response: bool | None = None,
|
|
23
|
+
webhook_url: str | None = None,
|
|
24
|
+
webhook_secret: str | None = None,
|
|
25
|
+
) -> Job:
|
|
26
|
+
"""Submit a text-to-embedding job."""
|
|
27
|
+
url = self._client._resolve_endpoint("txt2embedding")
|
|
28
|
+
payload = _build_embedding_payload(
|
|
29
|
+
input=input, model=model,
|
|
30
|
+
return_result_in_response=return_result_in_response,
|
|
31
|
+
webhook_url=webhook_url, webhook_secret=webhook_secret,
|
|
32
|
+
)
|
|
33
|
+
resp = self._client.post(url, json=payload)
|
|
34
|
+
request_id = resp["data"]["request_id"]
|
|
35
|
+
status_url = self._client._resolve_endpoint("request_status")
|
|
36
|
+
return Job(request_id, self._client, status_url)
|
|
37
|
+
|
|
38
|
+
def create_price(
|
|
39
|
+
self,
|
|
40
|
+
*,
|
|
41
|
+
input: str | list[str],
|
|
42
|
+
model: str,
|
|
43
|
+
return_result_in_response: bool | None = None,
|
|
44
|
+
) -> PriceResult:
|
|
45
|
+
"""Calculate price for text-to-embedding."""
|
|
46
|
+
url = self._client._resolve_endpoint("txt2embedding_price")
|
|
47
|
+
payload = _build_embedding_payload(
|
|
48
|
+
input=input, model=model,
|
|
49
|
+
return_result_in_response=return_result_in_response,
|
|
50
|
+
)
|
|
51
|
+
resp = self._client.post(url, json=payload)
|
|
52
|
+
return PriceResult.model_validate(resp.get("data", resp))
|
|
53
|
+
|
|
54
|
+
|
|
55
|
+
class AsyncEmbeddings:
|
|
56
|
+
"""Async embeddings resource."""
|
|
57
|
+
|
|
58
|
+
def __init__(self, client: AsyncHTTPClient) -> None:
|
|
59
|
+
self._client = client
|
|
60
|
+
|
|
61
|
+
async def create(
|
|
62
|
+
self,
|
|
63
|
+
*,
|
|
64
|
+
input: str | list[str],
|
|
65
|
+
model: str,
|
|
66
|
+
return_result_in_response: bool | None = None,
|
|
67
|
+
webhook_url: str | None = None,
|
|
68
|
+
webhook_secret: str | None = None,
|
|
69
|
+
) -> AsyncJob:
|
|
70
|
+
"""Submit a text-to-embedding job."""
|
|
71
|
+
url = self._client._resolve_endpoint("txt2embedding")
|
|
72
|
+
payload = _build_embedding_payload(
|
|
73
|
+
input=input, model=model,
|
|
74
|
+
return_result_in_response=return_result_in_response,
|
|
75
|
+
webhook_url=webhook_url, webhook_secret=webhook_secret,
|
|
76
|
+
)
|
|
77
|
+
resp = await self._client.post(url, json=payload)
|
|
78
|
+
request_id = resp["data"]["request_id"]
|
|
79
|
+
status_url = self._client._resolve_endpoint("request_status")
|
|
80
|
+
return AsyncJob(request_id, self._client, status_url)
|
|
81
|
+
|
|
82
|
+
async def create_price(
|
|
83
|
+
self,
|
|
84
|
+
*,
|
|
85
|
+
input: str | list[str],
|
|
86
|
+
model: str,
|
|
87
|
+
return_result_in_response: bool | None = None,
|
|
88
|
+
) -> PriceResult:
|
|
89
|
+
"""Calculate price for text-to-embedding."""
|
|
90
|
+
url = self._client._resolve_endpoint("txt2embedding_price")
|
|
91
|
+
payload = _build_embedding_payload(
|
|
92
|
+
input=input, model=model,
|
|
93
|
+
return_result_in_response=return_result_in_response,
|
|
94
|
+
)
|
|
95
|
+
resp = await self._client.post(url, json=payload)
|
|
96
|
+
return PriceResult.model_validate(resp.get("data", resp))
|
|
97
|
+
|
|
98
|
+
|
|
99
|
+
# --- Private helpers ---
|
|
100
|
+
|
|
101
|
+
def _build_embedding_payload(
|
|
102
|
+
*,
|
|
103
|
+
input: str | list[str],
|
|
104
|
+
model: str,
|
|
105
|
+
return_result_in_response: bool | None = None,
|
|
106
|
+
webhook_url: str | None = None,
|
|
107
|
+
webhook_secret: str | None = None,
|
|
108
|
+
) -> dict[str, Any]:
|
|
109
|
+
payload: dict[str, Any] = {
|
|
110
|
+
"input": input,
|
|
111
|
+
"model": model,
|
|
112
|
+
}
|
|
113
|
+
if return_result_in_response is not None:
|
|
114
|
+
payload["return_result_in_response"] = return_result_in_response
|
|
115
|
+
payload.update(webhook_fields(webhook_url, webhook_secret))
|
|
116
|
+
return payload
|