Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

xAI SDK u l-Polling Awtomatiku

Lezzjoni 11 / 12 Aġġornat 2 ta’ Novembru 2026 Livell Medju
F'din il-paġna
  1. Issimplifika l-polling bis-SDK
  2. Sejħa waħda minflok loop
  3. Iġġestixxi l-iżbalji fis-sors
  4. Editing u estensjoni, l-istess faċilità
  5. Qatt ma tħalli vidjow fis-sħaba
  6. Iġġenera vidjowijiet multipli f’daqqa
  7. Għandek tabbanduna l-polling manwali?
  8. Punti Ewlenin

Aġġornat fit-2 ta’ Novembru, 2026 abbażi tad-dokumentazzjoni tal-vidjow ta’ xAI u l-kodiċi xai-sdk 1.21.0: il-metodi huma msejħa client.video.generate u client.video.extend (l-editing juża generate b’video_url), ir-riżultat jesponi url, id-dewmien jiġi stabbilit permezz ta’ timedelta, u l-intervall default tal-polling huwa sekonda waħda. await jeħtieġ il-klijent asinkronu AsyncClient, u l-eċċezzjoni VideoGenerationError tiġi importata minn xai_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.

ŻballKawżaAzzjoni rrakkomandata
VideoGenerationErrorFalliment 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
TimeoutErrorIl-ħin ta’ stennija naqas fuq in-naħa tal-klijentŻid it-timeout jew naqqas id-durata
RuntimeErrorIt-talba ddiferita skadiet, jew tlestiet mingħajr riżultatErġa’ ibda l-ġenerazzjoni
grpc.RpcErrorŻball fit-trasport tal-SDK, inklużi limiti ta’ rata (kodiċi RESOURCE_EXHAUSTED) u problemi taċ-ċavettaIbgħ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.

AspettPolling manwaliSDK
KumplessitàGħoljaBaxxa
Ġestjoni tal-iżbaljiBiex tiġi implimentataIntegrata
TimeoutBiex tiġi implimentata10 min default, konfigurabbli
Intervall tal-pollingBiex jintgħażel1 s default, konfigurabbli
FlessibbiltàTotaliStandard (jew start u get)
DipendenzaL-ebda waħdaxAI 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.generate tissottometti, tistenna u tirritorna l-vidjow (url, duration, model); timeout ta’ 10 minuti u verifika kull sekonda b’mod default
  • L-editing juża generate b’video_url, l-estensjoni tuża client.video.extend
  • VideoGenerationError (minn xai_sdk.video), TimeoutError, u RuntimeError jiddistingwu l-fallimenti; il-limiti tar-rata jaslu bħala grpc.RpcError
  • Dejjemniżżel il-vidjow immedjatament wara l-ġenerazzjoni (URLs temporanji)
  • Il-klijent asinkronu u asyncio.gather jipparallelizzaw batch, fil-limiti tar-rata tat-tier tiegħek