xAI SDK un automātiskā aptauja
Šajā lapā
Atjaunināts 2026. gada 2. novembrī, pamatojoties uz xAI video dokumentāciju un
xai-sdk1.21.0 kodu: metodes tiek sauktasclient.video.generateunclient.video.extend(redigēšanai izmantogeneratearvideo_url), rezultāts nodrošinaurl, aizkave tiek iestatīta, izmantojottimedelta, un noklusējuma aptaujas intervāls ir viena sekunde.awaitprasa asinhrono klientuAsyncClient, un izņēmumsVideoGenerationErrortiek importēts noxai_sdk.video. Vecajā versijā tika izmantotas metodes un izņēmumu moduļi, kas nepastāv. Avoti: Video ģenerēšana · Video rediģēšana · Video pagarināšana · xai-sdk-python.
Vienkāršo aptauju, izmantojot SDK
Iepriekšējā nodarbībā tev bija jāuzraksta aptaujas cikls ar rokām. Tas ir noderīgs vingrinājums, lai saprastu ģenerēšanas dzīves ciklu, taču tas nozīmē arī trīsdesmit koda rindiņas, kas jāuztur katrā projektā, ar savu laika limita apstrādi, kļūmju gadījumiem un statusa konvertēšanu. xAI oficiālais Python SDK (pip install xai-sdk) to visu encapsulē: tu iesniedz pieprasījumu, un tas parūpējas par gaidīšanu.
Viens izsaukums cikla vietā
Metode client.video.generate apvieno iesniegšanu, izsekošanu un iegūšanu. Tā atgriež kontroli tikai tad, kad video ir gatavs, vai izraisa izņēmumu, ja kaut kas ir nogājis greizi.
import os
import xai_sdk
client = xai_sdk.Client(api_key=os.getenv("XAI_API_KEY"))
# Teksta uz video ģenerēšana ar automātisko aptauju
video = client.video.generate(
prompt="Saullēkts pār Alpiem, paātrināts laika intervāls",
model="grok-imagine-video-1.5",
duration=5,
aspect_ratio="16:9",
resolution="720p",
)
print(video.url)
print(f"Ilgums: {video.duration} s, modelis: {video.model}")
Aiz šīm dažām rindiņām SDK dara tieši to, ko tu kodēji iepriekš: iesniedz pieprasījumu, pēc noklusējuma katru sekundi aptaujā statusu un pēc tam atgriež rezultātu vai izraisa izņēmumu atkarībā no iznākuma.
Viens iestatījums ir pelnījis tavu uzmanību jau izvietošanas brīdī: pēc noklusējuma SDK gaida līdz 10 minūtēm, pirms padodas. Tas ir ērti nakts ražošanas skriptam, bet daudz par ilgu tīmekļa pieprasījumam, kur lietotājs gaida atbildi. Parametri timeout un interval, abi ir timedelta objekti, nosaka limitu un ritmu:
from datetime import timedelta
video = client.video.generate(
prompt="Tavs apraksts",
model="grok-imagine-video-1.5",
duration=10,
timeout=timedelta(minutes=5), # maks. 5 minūtes
interval=timedelta(seconds=5), # viena pārbaude ik pēc 5 sekundēm
)
Ja vēlies saglabāt kontroli pār gaidīšanu – piemēram, lai pārsūtītu progresu –, client.video.start iesniedz pieprasījumu un atgriež tā request_id, ko pēc tam aptaujā client.video.get.
Apstrādā kļūdas to avotā
SDK atšķir kļūmes, kas pasargā tevi no virkņu analīzes, lai noskaidrotu, kas noticis:
from xai_sdk.video import VideoGenerationError
try:
video = client.video.generate(
prompt="Tavs apraksts",
model="grok-imagine-video-1.5",
duration=5,
)
print(f"Video gatavs: {video.url}")
except VideoGenerationError as e:
print(f"Ģenerēšana neizdevās [{e.code}]: {e.message}")
except TimeoutError:
print("Laika limits pārsniegts: palielini laika limitu vai vienkāršo pieprasījumu")
Katrai kļūdai ir nepieciešama atšķirīga reakcija, un to sajaukšana noved pie bezjēdzīgiem atkārtojumu cikliem vai, vēl ļaunāk, pie apmaksātām ģenerēšanām, kas nedod nekādu rezultātu.
| Kļūda | Cēlonis | Ieteicamā darbība |
|---|---|---|
VideoGenerationError | API signalizēta kļūme: noraidīts uzvednis, nederīgs avots, pārslogots serviss… (code, message) | Izlasi kodu: labo pieprasījumu vai mēģini vēlāk, ja serviss bija nepieejams |
TimeoutError | Klienta puses gaidīšanas laiks pārsniegts | Palielini timeout vai samazini ilgumu |
RuntimeError | Atliktais pieprasījums ir beidzies vai pabeigts bez rezultāta | Restartē ģenerēšanu |
grpc.RpcError | SDK transporta kļūda, ieskaitot ātruma limitus (kods RESOURCE_EXHAUSTED) un atslēgu problēmas | Atstarpē pieprasījumus ar atkāpšanos vai pārbaudi atslēgu |
SDK izmanto gRPC: pārsniegts ātruma limits šeit neparādās kā HTTP 429 kods, bet gan kā grpc.RpcError ar kodu RESOURCE_EXHAUSTED.
Rediģēšana un pagarināšana ar tādu pašu vieglumu
Rediģēšanai nav īpašas metodes: tas ir generate ar avota video, kas padots kā video_url (video līdz 8,7 sekundēm, tāds pats izejas ilgums, maks. 720p).
video = client.video.generate(
prompt="Pārveido ainu japāņu animē stilā",
model="grok-imagine-video",
video_url="https://example.com/video.mp4",
)
Pagarināšana pagarina 2 līdz 15 sekunžu secību par 2 līdz 10 sekunžu segmentu un atgriež pilnu video:
video = client.video.extend(
prompt="Turpini ainu ar panorāmu pa labi",
model="grok-imagine-video",
video_url="https://example.com/video.mp4",
duration=5,
)
Ņem vērā atšķirību no REST API: SDK pieņem video kā video_url parametru, savukārt JSON ķermenis sagaida video objektu ar tā url īpašību.
Nekad neatstāj video mākonī
SDK nemaina neko attiecībā uz rezultātu URL pagaidu dabu. Ja tavs kods vienkārši attēlo video.url, tu esi samaksājis par ģenerēšanu, kas drīz pazudīs. Labākā prakse ir ķēdēt ģenerēšanu un lejupielādi vienā funkcijā, lai kļūtu neiespējami aizmirst šo soli.
from pathlib import Path
import httpx
async def generate_and_save(client, prompt, output_file, **options):
"""Ģenerē video un saglabā to lokāli (klients: xai_sdk.AsyncClient)."""
video = await client.video.generate(
prompt=prompt,
model="grok-imagine-video-1.5",
**options,
)
# Tūlītēja lejupielāde
async with httpx.AsyncClient() as http:
response = await http.get(video.url)
response.raise_for_status()
Path(output_file).write_bytes(response.content)
print(f"Video saglabāts: {output_file}")
return output_file
Glabāšanai bez pārsūtīšanas caur tavu serveri ģenerēšanas parametrs storage_options nogulsnē video xAI Files API ar tavu izvēlētu derīguma termiņu.
Ģenerē vairākus video vienlaikus
Izmantojot asinhrono klientu, katrs izsaukums ir korutīns, un asyncio.gather palaiž visu partiju paralēli. Opcija return_exceptions=True šeit ir izšķiroša: bez tās viens noraidīts pieprasījums izgāztu visu partiju, un tu zaudētu jau iegūtos rezultātus.
import asyncio
import os
import xai_sdk
async def parallel_generation(requests):
"""Ģenerē vairākus video paralēli."""
client = xai_sdk.AsyncClient(api_key=os.getenv("XAI_API_KEY"))
tasks = [
client.video.generate(
prompt=req["prompt"],
model="grok-imagine-video-1.5",
duration=req.get("duration", 5),
aspect_ratio=req.get("aspect_ratio", "16:9"),
)
for req in requests
]
results = await asyncio.gather(*tasks, return_exceptions=True)
for i, res in enumerate(results, 1):
if isinstance(res, Exception):
print(f"Pieprasījums {i} neizdevās: {res}")
else:
print(f"Pieprasījums {i} pabeigts: {res.url}")
return results
Šo paralelizāciju ierobežo divi drošības mehānismi. Iesniegumi patērē tavu ātruma limitu, kas tiek skaitīts pieprasījumos sekundē atbilstoši tavas komandas līmenim (10 ieejas līmenī video modeļiem): lielai partijai ierobežo vienlaicīgumu ar asyncio.Semaphore. Atceries arī to, ko paralelisms dara un ko nedara: tas nepaātrina nevienu individuālu ģenerēšanu, tas tikai samazina kopējo partijas laiku.
Vai atteikties no manuālās aptaujas?
Ne sistemātiski. Turpmākais salīdzinājums parāda, kur katra pieeja gūst pārsvaru.
| Aspekts | Manuālā aptauja | SDK |
|---|---|---|
| Sarežģītība | Augsta | Zema |
| Kļūdu apstrāde | Jāievieš | Integrēta |
| Laika limits | Jāievieš | Noklusējums 10 min, konfigurējams |
| Aptaujas intervāls | Jāizvēlas | Noklusējums 1 s, konfigurējams |
| Elastība | Pilnīga | Standarta (vai start un get) |
| Atkarība | Nav | xAI SDK |
Manuālajai aptaujai saglabājas nozīme divās situācijās: kad tev ir nepieciešama smalka kontrole, piemēram, lai pārsūtītu progresu reāllaika saskarnei vai integrētu to esošā rindu sistēmā, un kad tavs izvietošanas konteksts aizliedz pievienot papildu atkarību.
Galvenās atziņas
client.video.generateiesniedz, gaida un atgriež video (url,duration,model); noklusējuma laika limits 10 minūtes un pārbaude ik pēc vienas sekundes- Rediģēšanai izmanto
generatearvideo_url, pagarināšanai izmantoclient.video.extend VideoGenerationError(noxai_sdk.video),TimeoutErrorunRuntimeErroratšķir kļūmes; ātruma limiti nāk kāgrpc.RpcError- Vienmēr lejupielādē video tūlīt pēc ģenerēšanas (pagaidu URL)
- Asinhronais klients un
asyncio.gatherparalelizē partiju, ievērojot tava līmeņa ātruma limitu