xAI SDK u l-Polling Awtomatiku
F'din il-paġna
Aġġornat fit-2 ta’ Novembru, 2026 abbażi tad-dokumentazzjoni tal-vidjow ta’ xAI u l-kodiċi
xai-sdk1.21.0: il-metodi huma msejħaclient.video.generateuclient.video.extend(l-editing jużagenerateb’video_url), ir-riżultat jesponiurl, id-dewmien jiġi stabbilit permezz ta’timedelta, u l-intervall default tal-polling huwa sekonda waħda.awaitjeħtieġ il-klijent asinkronuAsyncClient, u l-eċċezzjoniVideoGenerationErrortiġi importata minnxai_sdk.video. Il-verżjoni l-qadima sejħet metodi u modulu ta’ eċċezzjoni li ma jeżistux. Sorsi: Video Generation · Video Editing · Video Extension · xai-sdk-python.
Issimplifika l-polling bis-SDK
Il-lezzjoni preċedenti talbetlek tikseb loop tal-polling bl-idejk. Dan huwa eżerċizzju utli biex tifhem iċ-ċiklu tal-ħajja tal-ġenerazzjoni, iżda huwa wkoll tletin linja ta’ kodiċi li trid iżżomm f’kull proġett, bit-trattament tat-timeout tiegħu stess, il-każijiet ta’ falliment, u l-konverżjonijiet tal-istatus. Is-SDK uffiċjali ta’ Python ta’ xAI (pip install xai-sdk) jinkapsula dan kollu: inti tibgħat it-talba, u huwa jittratta l-istennija.
Sejħa waħda minflok loop
Il-metodu client.video.generate jiġbor flimkien is-sottomissjoni, it-traċċar u l-irkupru. Dan jirritorna l-kontroll biss meta l-vidjow ikun lest, jew iqajjem eċċezzjoni jekk xi ħaġa tmur ħażin.
import os
import xai_sdk
client = xai_sdk.Client(api_key=os.getenv("XAI_API_KEY"))
# Ġenerazzjoni minn test għal vidjow b'polling awtomatiku
video = client.video.generate(
prompt="Tlugħ ix-xemx fuq l-Alpi, time-lapse aċċellerat",
model="grok-imagine-video-1.5",
duration=5,
aspect_ratio="16:9",
resolution="720p",
)
print(video.url)
print(f"Durata: {video.duration} s, mudell: {video.model}")
Wara dawn il-ftit linji, is-SDK jagħmel eżattament dak li kkodifikajt qabel: jibgħat it-talba, jivverifika l-istatus kull sekonda b’mod default, imbagħad jirritorna r-riżultat jew iqajjem eċċezzjoni skont ir-riżultat.
Setting wieħed jistħoqqilha attenzjoni tiegħek mill-bidu tad-deploy: b’mod default, is-SDK jistenna sa 10 minuti qabel ma jirrinunzja. Dan huwa komdu għal skript ta’ produzzjoni ta’ kull lejl, iżda twil wisq għal talba web fejn utent qed jistenna tweġiba. Il-parametri timeout u interval, it-tnejn oġġetti timedelta, jistabbilixxu l-limitu u r-ritmu:
from datetime import timedelta
video = client.video.generate(
prompt="Id-deskrizzjoni tiegħek",
model="grok-imagine-video-1.5",
duration=10,
timeout=timedelta(minutes=5), # massimu 5 minuti
interval=timedelta(seconds=5), # verifika kull 5 sekondi
)
Jekk trid iżżomm il-kontroll fuq l-istennija—pereżempju, biex tgħaddi l-progress—client.video.start tibgħat it-talba u tirritorna l-request_id tagħha, li mbagħad client.video.get tistaqsi.
Iġġestixxi l-iżbalji fis-sors
Is-SDK jiddistingwi l-fallimenti, li jiffrankalek milli tanalizza l-istringi biex tifhem x’ġara:
from xai_sdk.video import VideoGenerationError
try:
video = client.video.generate(
prompt="Id-deskrizzjoni tiegħek",
model="grok-imagine-video-1.5",
duration=5,
)
print(f"Vidjow lest: {video.url}")
except VideoGenerationError as e:
print(f"Il-ġenerazzjoni falliet [{e.code}]: {e.message}")
except TimeoutError:
print("Timeout maqbuż: żid it-timeout jew issimplifika t-talba")
Kull żball jeħtieġ reazzjoni differenti, u li tħawwad bejniethom iwassal għal loops ta’ retry inutili jew, agħar minn hekk, ġenerazzjonijiet iffatturati li ma jipproduċu xejn.
| Żball | Kawża | Azzjoni rrakkomandata |
|---|---|---|
VideoGenerationError | Falliment sinjalat mill-API: prompt miċħud, sors invalidu, servizz overloadjat… (code, message) | Aqra l-kodiċi: irranġa t-talba, jew ipprova mill-ġdid aktar tard jekk is-servizz ma kienx disponibbli |
TimeoutError | Il-ħin ta’ stennija naqas fuq in-naħa tal-klijent | Żid it-timeout jew naqqas id-durata |
RuntimeError | It-talba ddiferita skadiet, jew tlestiet mingħajr riżultat | Erġa’ ibda l-ġenerazzjoni |
grpc.RpcError | Żball fit-trasport tal-SDK, inklużi limiti ta’ rata (kodiċi RESOURCE_EXHAUSTED) u problemi taċ-ċavetta | Ibgħed it-talbiet b’backoff, jew iċċekkja ċ-ċavetta |
Is-SDK juża gRPC: limitu ta’ rata maqbuż ma jidhirx bħala kodiċi HTTP 429 hawnhekk, iżda bħala grpc.RpcError bil-kodiċi RESOURCE_EXHAUSTED.
Editing u estensjoni, l-istess faċilità
L-editing m’għandux metodu ddedikat: huwa generate b’vidjow sors, mgħoddi bħala video_url (vidjow sa 8.7 sekondi, l-istess durata tal-output, massimu 720p).
video = client.video.generate(
prompt="Ibiddel ix-xena f'stil anime Ġappuniż",
model="grok-imagine-video",
video_url="https://example.com/video.mp4",
)
L-estensjoni ttawwal sekwenza ta’ bejn 2 u 15-il sekonda b’segment ta’ bejn 2 u 10 sekondi, u tirritorna l-vidjow sħiħ:
video = client.video.extend(
prompt="Kompli x-xena b'panoramika lejn il-lemin",
model="grok-imagine-video",
video_url="https://example.com/video.mp4",
duration=5,
)
Innota d-differenza mal-API REST: is-SDK jieħu l-vidjow bħala parametru video_url, filwaqt li l-ġisem JSON jistenna oġġett video bil-proprjetà url tiegħu.
Qatt ma tħalli vidjow fis-sħaba
Is-SDK ma jbiddel xejn fin-natura temporanja tal-URLs tar-riżultati. Jekk il-kodiċi tiegħek sempliċiment juri video.url, inti ħallast għal ġenerazzjoni li dalwaqt se tisparixxi. L-aħjar prattika hija li tgħaqqad il-ġenerazzjoni u t-tniżżil fl-istess funzjoni, sabiex ikun impossibbli li tinsa dan il-pass.
from pathlib import Path
import httpx
async def generate_and_save(client, prompt, output_file, **options):
"""Tiġġenera vidjow u tħalltu lokalment (client: xai_sdk.AsyncClient)."""
video = await client.video.generate(
prompt=prompt,
model="grok-imagine-video-1.5",
**options,
)
# Tniżżil immedjat
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"Vidjow maħżun: {output_file}")
return output_file
Għall-ħażna mingħajr tranżitu permezz tas-server tiegħek, il-parametru storage_options tal-ġenerazzjoni jiddepożita l-vidjow fl-API tal-Fajls ta’ xAI, b’skada ta’ għażla tiegħek.
Iġġenera vidjowijiet multipli f’daqqa
Mal-klijent asinkronu, kull sejħa hija coroutine, u asyncio.gather tniedi batch sħiħ b’mod parallel. L-għażla return_exceptions=True hija deċiżiva hawnhekk: mingħajrha, talba waħda miċħuda tfalli l-batch kollha u titlef ir-riżultati diġà miksuba.
import asyncio
import os
import xai_sdk
async def parallel_generation(requests):
"""Tiġġenera vidjowijiet multipli b'mod parallel."""
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"It-talba {i} falliet: {res}")
else:
print(f"It-talba {i} tlestiet: {res.url}")
return results
Żewġ guardrails jifframjaw din il-parallelizzazzjoni. Is-sottomissjonijiet jikkunsmaw il-limitu tar-rata tiegħek, magħdud f’talbiet kull sekonda skont it-tier tat-tim tiegħek (10 fit-tier tad-dħul għal mudelli tal-vidjow): għal batch kbir, orbot il-konkorrenza b’asyncio.Semaphore. Ftakar ukoll x’jagħmel u x’ma jagħmilx il-paralleliżmu: ma jaċċellerax kull ġenerazzjoni individwali, iżda biss inaqqas il-ħin totali tal-batch.
Għandek tabbanduna l-polling manwali?
Mhux sistematikament. Il-konfront li ġej juri fejn kull approċċ jieħu l-inizjattiva.
| Aspett | Polling manwali | SDK |
|---|---|---|
| Kumplessità | Għolja | Baxxa |
| Ġestjoni tal-iżbalji | Biex tiġi implimentata | Integrata |
| Timeout | Biex tiġi implimentata | 10 min default, konfigurabbli |
| Intervall tal-polling | Biex jintgħażel | 1 s default, konfigurabbli |
| Flessibbiltà | Totali | Standard (jew start u get) |
| Dipendenza | L-ebda waħda | xAI SDK |
Il-polling manwali jżomm ir-rilevanza tiegħu f’żewġ sitwazzjonijiet: meta teħtieġ kontroll fin, pereżempju biex tgħaddi l-progress lil interfaċċa f’ħin reali jew biex tintegra f’sistema ta’ queue eżistenti, u meta l-kuntest tad-deploy tiegħek jipprojbixxi li żżid dipendenza addizzjonali.
Punti Ewlenin
client.video.generatetissottometti, tistenna u tirritorna l-vidjow (url,duration,model); timeout ta’ 10 minuti u verifika kull sekonda b’mod default- L-editing juża
generateb’video_url, l-estensjoni tużaclient.video.extend VideoGenerationError(minnxai_sdk.video),TimeoutError, uRuntimeErrorjiddistingwu l-fallimenti; il-limiti tar-rata jaslu bħalagrpc.RpcError- Dejjemniżżel il-vidjow immedjatament wara l-ġenerazzjoni (URLs temporanji)
- Il-klijent asinkronu u
asyncio.gatherjipparallelizzaw batch, fil-limiti tar-rata tat-tier tiegħek