Loo partiiülesanne, jälgi olekut ja laadi tulemused alla
Sellel lehel
Uuendatud 3. novembril 2026: Lisand 3. novembriks:
files.downloadtagastab HTTP vastuse (httpx2.Response); loe selle sisu meetodiga.read()enne.decode()kutsumist. Üleslaadimine eeldab vormingutfile={"file_name": …, "content": …}. API võti ei ole enam koodi sisse kirjutatud.
JSONL-failist tulemusteni: kogu elutsükkel
Su JSONL-fail on ette valmistatud ja üles laaditud ning sul on olemas file_id. Järgmine samm on muuta see seisvas olekus fail kasutatavateks tulemusteks: loo partiiülesanne (batch job), jälgi selle edenemist minutite või tundide vältel, mis töötlemine aega võtab, ning seejärel too vastused kätte ja vii need omavahel kooskõlla. Selles õppetükis käime läbi kogu Pythoni koodi otsast lõpuni täpselt selles järjekorras, nagu sa selle kirjutad.
Partiiülesande loomine
Loomine nõuab ühteainsat väljakutset. Määrad allikafaili, mudeli ja sihtotstarbelise lõpp-punkti:
from mistralai.client import Mistral
import time
client = Mistral(api_key="your-api-key")
# Loo partiiülesanne
job = client.batch.jobs.create(
input_files=[batch_file.id], # Üles laaditud faili ID
model="mistral-small-latest",
endpoint="/v1/chat/completions",
metadata={"project": "document-analysis", "version": "1.0"}
)
print(f"Ülesanne loodud: {job.id}")
print(f"Algne olek: {job.status}")
Iga parameeter väärib märkust:
input_files– Üles laaditud faili ID-de loend. Saad ühele ülesandele edastada mitu faili.model– Kasutatav Mistrali mudel. Ühe partiiülesande kohta ainult üks mudel.endpoint– Siht-API lõpp-punkt (peab vastama sinu JSONL-failis olevalebodyvormingule).metadata– Valikuline sõnastik kohandatud metaandmetega, et oma ülesandeid organiseerida ja leida.
Piirang „üks mudel ülesande kohta“ määrab kindlaks, kuidas oma tööd jaotad: kui soovid võrrelda kahte mudelit sama korpuse põhjal, esita kaks eraldiseisvat ülesannet, mis viitavad samale failile. Mis puutub metaandmetesse, siis need võivad tunduda kõrvalistena, kuni sul on ajaloos kolmkümmend ülesannet; ülal näidatud projekti/versiooni paar võimaldab siis leida partii, mis produtseeris küsitavaid andmeid, kolme sekundiga.
Partiiülesande olekud
Partiiülesanne läbib oma elutsükli jooksul mitmeid olekuid:
| Olek | Kirjeldus |
|---|---|
QUEUED | Järjekorras, veel mitte alanud |
RUNNING | Töötlemine käimas |
SUCCESS | Edukalt lõpetatud |
FAILED | Töötlemine ebaõnnestus |
TIMEOUT_EXCEEDED | Täitmise aeg ületati |
CANCELLATION_REQUESTED | Tühistamine taotletud |
CANCELLED | Tühistatud |
Neist seitsmest olekust on neli lõplikud – SUCCESS, FAILED, TIMEOUT_EXCEEDED ja CANCELLED – ning just see eristus juhib jälgimistsüklit: seni kuni olek ei kuulu sellesse hulka, on ülesanne veel elus ja sa pead ootama. Eelkõige CANCELLATION_REQUESTED ei ole peatunud olek, vaid üleminekuolek; kood, mis käsitleks seda lõplikuna, väljuks tsüklist liiga vara.
Edenemise jälgimine
Allpool olev polling-muster (päringute tsükkel) kehastab seda loogikat täpselt, lisades maksimaalse kestuse piirangu, et vältida ununenud skripti lõputut jooksmist:
def wait_for_batch(client, job_id, poll_interval=10, max_wait=3600):
"""Oota partiiülesande lõpetamist, kasutades pollingut."""
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] Olek: {job.status}")
if job.status in terminal_states:
return job
time.sleep(poll_interval)
elapsed += poll_interval
raise TimeoutError(f"Ülesanne {job_id} töötab endiselt pärast {max_wait}s")
# Kasutamine
completed_job = wait_for_batch(client, job.id)
print(f"Lõpptulemus: {completed_job.status}")
Kümne sekundi pikkune intervall sobib mõni minut kestva partii jaoks; ühe öö jooksul sadu tuhandeid ridu töötleva ülesande puhul suurenda seda minutiks või enamaks. Suurem polling-täpsus ei too seal mingit lisaväärtust ja tekitab vaid tarbetuid API väljakutseid.
Tulemuste allalaadimine
Kui olek jõuab väärtuseni SUCCESS, paljastab ülesanne output_file, mille saad alla laadida ja rea haaval parsida:
import json
if completed_job.status == "SUCCESS":
# Hangi väljundfaili ID
output_file_id = completed_job.output_file
# Laadi sisu alla
result_data = client.files.download(file_id=output_file_id)
# Parsi JSONL tulemused
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
# Näita näidet
for cid, resp in list(results.items())[:3]:
content = resp["body"]["choices"][0]["message"]["content"]
print(f"\n--- {cid} ---")
print(content[:200])
Tulemuste fail on samuti JSONL-vormingus ja iga rida sisaldab algset custom_id koos mudeli täieliku vastusega. Siin tasub ära eelmises õppetükis tehtud nimetamis töö: indekseerimine custom_id järgi sõnastikus piisab vastuste kooskõlla viimiseks sinu lähtedokumentidega, sõltumata nende tagasijõudmise järjekorrast. Esimese kolme kirje kuvamine, lühendatuna 200 märgini, on kasulik usaldusväärsuse kontroll enne, kui hakkad oma andmebaasi kirjutama.
Oma ülesannete loetlemine ja haldamine
Saad filtreerida ülesannete loendit oleku järgi, võimaldades igal hetkel näha, mis tegelikult sinu kontol töötab:
# Loetle kõik praegu töötavad ülesanded
running_jobs = client.batch.jobs.list(status="RUNNING")
for j in running_jobs.data:
print(f"Ülesanne {j.id} - Mudel: {j.model} - Loodud: {j.created_at}")
Ja kui ülesanne venib liiga pikaks või märkad pärast esitamist viiba viga, hoiab tühistamine sind asjatute töötlemiskulude eest:
# Tühista ülesanne, mis võtab liiga kaua aega
client.batch.jobs.cancel(job_id="job-abc123")
Tühistamine on asünkroonne: olek liigub esmalt väärtusele CANCELLATION_REQUESTED ja seejärel väärtusele CANCELLED, kui peatamine on jõustunud. Ära eelda, et ressurss vabaneb kohe pärast väljakutse tagasipöördumist.
Otsast lõpuni töövoog
Kokku panduna moodustavad need neli sammu lühikese skripti, mille saad otse planeerijasse (scheduler) paigutada:
from mistralai.client import Mistral
import json
import os
import time
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
# 1. Laadi fail üles
with open("batch_requests.jsonl", "rb") as f:
batch_file = client.files.upload(
file={"file_name": "batch_requests.jsonl", "content": f},
purpose="batch"
)
# 2. Loo ülesanne
job = client.batch.jobs.create(
input_files=[batch_file.id],
model="mistral-small-latest",
endpoint="/v1/chat/completions"
)
# 3. Oota lõpetamist
completed = wait_for_batch(client, job.id)
# 4. Laadi tulemused alla ja parsi need
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"Partii ebaõnnestus: {completed.status}")
Kasuta seda skeleti oma korpuse põhjal vaid kümne reaga: valideerid kogu ahela mõne minutiga enne, kui pühendud täismahule.
Peamised punktid
- Loo partiiülesanne käsuga
client.batch.jobs.create(), määrates faili, mudeli ja lõpp-punkti - Seitse võimalikku olekut, sealhulgas kolm lõplikku:
SUCCESS,FAILED,CANCELLED - Progressi jälgimise standardmuster on polling kindla intervalliga
- Tulemused on JSONL-vormingus ja seotud päringutega
custom_idkaudu - Saad oma ülesandeid igal ajal loetleda, inspecteerida ja tühistada