Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

xAI SDK un automātiskā aptauja

Nodarbība 11 no 12 Atjaunota 2026. gada 2. novembris Vidējs
Šajā lapā
  1. Vienkāršo aptauju, izmantojot SDK
  2. Viens izsaukums cikla vietā
  3. Apstrādā kļūdas to avotā
  4. Rediģēšana un pagarināšana ar tādu pašu vieglumu
  5. Nekad neatstāj video mākonī
  6. Ģenerē vairākus video vienlaikus
  7. Vai atteikties no manuālās aptaujas?
  8. Galvenās atziņas

Atjaunināts 2026. gada 2. novembrī, pamatojoties uz xAI video dokumentāciju un xai-sdk 1.21.0 kodu: metodes tiek sauktas client.video.generate un client.video.extend (redigēšanai izmanto generate ar video_url), rezultāts nodrošina url, aizkave tiek iestatīta, izmantojot timedelta, un noklusējuma aptaujas intervāls ir viena sekunde. await prasa asinhrono klientu AsyncClient, un izņēmums VideoGenerationError tiek importēts no xai_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ļūdaCēlonisIeteicamā darbība
VideoGenerationErrorAPI 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
TimeoutErrorKlienta puses gaidīšanas laiks pārsniegtsPalielini timeout vai samazini ilgumu
RuntimeErrorAtliktais pieprasījums ir beidzies vai pabeigts bez rezultātaRestartē ģenerēšanu
grpc.RpcErrorSDK transporta kļūda, ieskaitot ātruma limitus (kods RESOURCE_EXHAUSTED) un atslēgu problēmasAtstarpē 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.

AspektsManuālā aptaujaSDK
SarežģītībaAugstaZema
Kļūdu apstrādeJāieviešIntegrēta
Laika limitsJāieviešNoklusējums 10 min, konfigurējams
Aptaujas intervālsJāizvēlasNoklusējums 1 s, konfigurējams
ElastībaPilnīgaStandarta (vai start un get)
AtkarībaNavxAI 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.generate iesniedz, 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 generate ar video_url, pagarināšanai izmanto client.video.extend
  • VideoGenerationError (no xai_sdk.video), TimeoutError un RuntimeError atšķ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.gather paralelizē partiju, ievērojot tava līmeņa ātruma limitu