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

Izveidot paketes uzdevumu, izsekot tā statusam un lejupielādēt rezultātus

Nodarbība 3 no 16 Atjaunota 2026. gada 3. novembris Augstākais
Šajā lapā
  1. No JSONL faila līdz rezultātiem: Pilns dzīves cikls
  2. Paketes uzdevuma izveide
  3. Paketes uzdevuma statusi
  4. Progresa izsekošana
  5. Rezultātu lejupielāde
  6. Uzdevumu saraksta sastādīšana un pārvaldība
  7. Darbplūsma no sākuma līdz beigām
  8. Galvenās atziņas

Atjaunināts 2026. gada 3. novembrī: Pielikums 3. novembrim: files.download atgriež HTTP atbildi (httpx2.Response); pirms izsaukt .decode(), nolasiet tās saturu ar .read(). Augšupielāde sagaida file={"file_name": …, "content": …}. API atslēga vairs nav iekodēta.

No JSONL faila līdz rezultātiem: Pilns dzīves cikls

Tavs JSONL fails ir sagatavots un augšupielādēts, un tev ir file_id. Nākamais solis ir šī dīkstāvē esošā faila pārveidošana lietojamos rezultātos: izveido paketes uzdevumu, uzraugi tā gaitu minūšu vai stundu garumā, kamēr notiek apstrāde, un pēc tam iegūsti un saskaņo atbildes. Šī nodarbība soli pa solim izskaidro Python kodu tieši tādā secībā, kādā tu to rakstīsi.

Paketes uzdevuma izveide

Izveidei pietiek ar vienu izsaukumu. Tu norādi avota failu, modeli un mērķa galapunktu:

from mistralai.client import Mistral
import time

client = Mistral(api_key="your-api-key")

# Izveidot paketes uzdevumu
job = client.batch.jobs.create(
    input_files=[batch_file.id],   # Augšupielādētā faila ID
    model="mistral-small-latest",
    endpoint="/v1/chat/completions",
    metadata={"project": "document-analysis", "version": "1.0"}
)

print(f"Uzdevums izveidots: {job.id}")
print(f"Sākotnējais statuss: {job.status}")

Katrs parametrs ir pelnījis piezīmi:

  • input_files — Augšupielādēto failu ID saraksts. Vienam uzdevumam vari norādīt vairākus failus.
  • model — Izmantojamais Mistral modelis. Vienam paketes uzdevumam drīkst būt tikai viens modelis.
  • endpoint — Mērķa API galapunkts (tam jāsakrīt ar body formātu tavā JSONL).
  • metadata — Neobligāta vārdnīca ar pielāgotiem metadatiem, lai organizētu un atrastu savus uzdevumus.

Ierobežojums „viens modelis vienam uzdevumam” nosaka, kā sadalīt darbu: ja vēlies salīdzināt divus modeļus vienā un tajā pašā korpusā, iesniedz divus atsevišķus uzdevumus, kas norāda uz vienu un to pašu failu. Kas attiecas uz metadatiem, tie var šķist nebūtiski, līdz tavā vēsturē ir trīsdesmit uzdevumi; tad augstāk redzamais projekta/versijas pāris ļauj trīs sekundēs atrast paketi, kas ģenerējusi apšaubāmus datus.

Paketes uzdevuma statusi

Paketes uzdevums dzīves cikla laikā iziet cauri vairākiem stāvokļiem:

StatussApraksts
QUEUEDIerindots, vēl nav sācies
RUNNINGNotiek apstrāde
SUCCESSVeiksmīgi pabeigts
FAILEDApstrāde neizdevās
TIMEOUT_EXCEEDEDPārsniegts izpildes laika limits
CANCELLATION_REQUESTEDPieprasīta atcelšana
CANCELLEDAtcelts

Četri no šiem septiņiem stāvokļiem ir termināli — SUCCESS, FAILED, TIMEOUT_EXCEEDED un CANCELLED — un tieši šī atšķirība virza uzraudzības ciklu: kamēr statuss nav šajā kopā, uzdevums joprojām ir aktīvs un tev jāgaida. Jo īpaši CANCELLATION_REQUESTED nav apturēts stāvoklis, bet gan pārejas posms; kods, kas to uzskatītu par terminālu, pārtrauktu ciklu pārāk agri.

Progresa izsekošana

Zemāk esošais aptaujas (polling) raksts precīzi ietver šo loģiku, iekļaujot maksimālā ilguma drošības mehānismu, lai novērstu aizmirsta skripta bezgalīgu darbību:

def wait_for_batch(client, job_id, poll_interval=10, max_wait=3600):
    """Gaidīt, kamēr paketes uzdevums pabeigts, izmantojot aptauju."""
    elapsed = 0
    terminal_states = {"SUCCESS", "FAILED", "TIMEOUT_EXCEEDED", "CANCELLED"}

    while elapsed < max_wait:
        job = client.batch.jobs.get(job_id=job_id)
        print(f"[{elapsed}s] Statuss: {job.status}")

        if job.status in terminal_states:
            return job

        time.sleep(poll_interval)
        elapsed += poll_interval

    raise TimeoutError(f"Uzdevums {job_id} joprojām darbojas pēc {max_wait}s")

# Lietojums
completed_job = wait_for_batch(client, job.id)
print(f"Gala rezultāts: {completed_job.status}")

Desmit sekunžu intervāls der paketei, kas ilgst dažas minūtes; ja apstrādā vairākus simtus tūkstošu rindu nakts laikā, palielini to līdz minūtei vai vairāk. Lielāka aptaujas precizitāte tur nedod nekādu vērtību un tikai uzkrāj liekus API izsaukumus.

Rezultātu lejupielāde

Kad statuss sasniedz SUCCESS, uzdevums piedāvā output_file, ko lejupielādē un parsē rindu pa rindai:

import json

if completed_job.status == "SUCCESS":
    # Iegūt izvades faila ID
    output_file_id = completed_job.output_file

    # Lejupielādēt saturu
    result_data = client.files.download(file_id=output_file_id)

    # Parsēt JSONL rezultātus
    results = {}
    for line in result_data.read().decode("utf-8").strip().split("\n"):
        entry = json.loads(line)
        custom_id = entry["custom_id"]
        response = entry["response"]
        results[custom_id] = response

    # Parādīt piemēru
    for cid, resp in list(results.items())[:3]:
        content = resp["body"]["choices"][0]["message"]["content"]
        print(f"\n--- {cid} ---")
        print(content[:200])

Rezultātu fails arī ir JSONL formātā, un katra rinda satur sākotnējo custom_id kopā ar modeļa pilno atbildi. Tieši šeit atmaksājas iepriekšējā nodarbībā ieguldītais darbs pie nosaukumiem: indeksēšana pēc custom_id vārdnīcā ir pietiekama, lai saskaņotu atbildes ar avota dokumentiem neatkarīgi no to atgriešanās secības. Pirmo trīs ierakstu parādīšana, saīsinot līdz 200 rakstzīmēm, ir noderīga veselības pārbaude pirms sāc rakstīt datubāzē.

Uzdevumu saraksta sastādīšana un pārvaldība

Vari filtrēt uzdevumu inventāru pēc statusa, ļaujot jebkurā brīdī redzēt, kas tieši darbojas tavā kontā:

# Sarakstīt visus pašlaik darbojošos uzdevumus
running_jobs = client.batch.jobs.list(status="RUNNING")
for j in running_jobs.data:
    print(f"Uzdevums {j.id} - Modelis: {j.model} - Izveidots: {j.created_at}")

Un, ja uzdevums ievelkas vai pēc iesniegšanas pamanīji kļūdu uzvednē, atcelšana ļauj izvairīties no maksāšanas par bezjēdzīgu apstrādi:

# Atcelt uzdevumu, kas aizņem pārāk daudz laika
client.batch.jobs.cancel(job_id="job-abc123")

Atcelšana ir asinhrona: statuss vispirms pāriet uz CANCELLATION_REQUESTED un tikai tad uz CANCELLED, kad apturēšana ir stājusies spēkā. Neuzskati resursu par atbrīvotu uzreiz pēc izsaukuma atgriešanās.

Darbplūsma no sākuma līdz beigām

Apvienojot šos četrus soļus, iegūsti īsu skriptu, ko vari tieši ievietot plānotājā:

from mistralai.client import Mistral
import json
import os
import time

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

# 1. Augšupielādēt failu
with open("batch_requests.jsonl", "rb") as f:
    batch_file = client.files.upload(
        file={"file_name": "batch_requests.jsonl", "content": f},
        purpose="batch"
    )

# 2. Izveidot uzdevumu
job = client.batch.jobs.create(
    input_files=[batch_file.id],
    model="mistral-small-latest",
    endpoint="/v1/chat/completions"
)

# 3. Gaidīt pabeigšanu
completed = wait_for_batch(client, job.id)

# 4. Lejupielādēt un parsēt rezultātus
if completed.status == "SUCCESS":
    data = client.files.download(file_id=completed.output_file)
    for line in data.read().decode("utf-8").strip().split("\n"):
        entry = json.loads(line)
        print(f"{entry['custom_id']}: OK")
else:
    print(f"Pakete neizdevās: {completed.status}")

Atkārtoti izmanto šo skeletu savam korpusam, pievienojot tikai desmit rindas: tu dažās minūtēs validēsi visu ķēdi, pirms pāriesi pie pilna apjoma.

Galvenās atziņas

  • Izveido paketes uzdevumu ar client.batch.jobs.create(), norādot failu, modeli un galapunktu
  • Septiņi iespējamie statusi, tostarp trīs terminālie: SUCCESS, FAILED, CANCELLED
  • Aptauja ar intervālu ir standarta raksts progresa izsekošanai
  • Rezultāti ir JSONL formātā, saistīti ar pieprasījumiem, izmantojot custom_id
  • Savus uzdevumus vari jebkurā laikā sarakstīt, inspectēt un atcelt