Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Skapa ett batchjobb, spåra status och ladda ner resultat

Lektion 3 av 16 Uppdaterad 3 november 2026 Avancerad
På denna sida
  1. Från JSONL-fil till resultat: Den kompletta livscykeln
  2. Skapa ett batchjobb
  3. Statusar för batchjobb
  4. Spåra framsteg
  5. Ladda ner resultat
  6. Lista och hantera dina jobb
  7. End-to-end-arbetsflöde
  8. Viktiga punkter

Uppdaterat 3 november 2026: Tillägg för 3 november: files.download returnerar ett HTTP-svar (httpx2.Response); läs innehållet med .read() innan du anropar .decode(). Uppladdning förväntar sig file={"file_name": …, "content": …}. API-nyckeln är inte längre hårdkodad.

Från JSONL-fil till resultat: Den kompletta livscykeln

Din JSONL-fil är förberedd och uppladdad, och du har ett file_id. Nästa steg är att omvandla den vilande filen till användbara resultat: skapa batchjobbet, övervaka dess framsteg under de minuter eller timmar bearbetningen tar, och hämta sedan samt stäm av svaren. Denna lektion går igenom den end-to-end Python-koden i exakt den ordning du kommer att skriva den.

Skapa ett batchjobb

Skapandet kräver ett enda anrop. Du anger källfilen, modellen och mål-endpointen:

from mistralai.client import Mistral
import time

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

# Skapa batchjobbet
job = client.batch.jobs.create(
    input_files=[batch_file.id],   # ID för den uppladdade filen
    model="mistral-small-latest",
    endpoint="/v1/chat/completions",
    metadata={"project": "document-analysis", "version": "1.0"}
)

print(f"Jobb skapat: {job.id}")
print(f"Initial status: {job.status}")

Varje parameter förtjänar en kommentar:

  • input_files – En lista med ID:n för uppladdade filer. Du kan skicka flera filer till ett enda jobb.
  • model – Mistral-modellen som ska användas. Endast en modell per batchjobb.
  • endpoint – Mål-API:endpoint (måste matcha body-formatet i din JSONL).
  • metadata – En valfri ordlista med anpassad metadata för att organisera och hämta dina jobb.

Begränsningen med en modell per jobb styr hur du delar upp ditt arbete: om du vill jämföra två modeller på samma korpus skickar du in två distinkta jobb som pekar på samma fil. Vad gäller metadata kan det verka oväsentligt tills du har trettio jobb i din historik; då låter projekt/version-paret ovan dig hitta batchen som producerade tveksamma data på tre sekunder flat.

Statusar för batchjobb

Ett batchjobb passerar genom flera tillstånd under sin livscykel:

StatusBeskrivning
QUEUEDKöad, ej startad än
RUNNINGBearbetning pågår
SUCCESSSlutförd framgångsrikt
FAILEDBearbetning misslyckades
TIMEOUT_EXCEEDEDExekveringstiden överskred tidsgränsen
CANCELLATION_REQUESTEDAvbrott begärt
CANCELLEDAvbruten

Fyra av dessa sju tillstånd är terminala – SUCCESS, FAILED, TIMEOUT_EXCEEDED och CANCELLED – och denna distinktion driver övervakningsloopen: så länge statusen inte finns i denna mängd är jobbet fortfarande vid liv och du måste vänta. CANCELLATION_REQUESTED är särskilt inte ett stoppat tillstånd utan ett övergångstillstånd; kod som behandlar det som terminalt skulle avsluta loopen för tidigt.

Spåra framsteg

Pollningsmönstret nedan kapslar in denna logik exakt, med en skyddsmekanism för maximal varaktighet för att förhindra att ett glömt skript körs i oändlighet:

def wait_for_batch(client, job_id, poll_interval=10, max_wait=3600):
    """Vänta på att ett batchjobb ska slutföras med hjälp av pollning."""
    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] Status: {job.status}")

        if job.status in terminal_states:
            return job

        time.sleep(poll_interval)
        elapsed += poll_interval

    raise TimeoutError(f"Jobb {job_id} kör fortfarande efter {max_wait}s")

# Användning
completed_job = wait_for_batch(client, job.id)
print(f"Slutresultat: {completed_job.status}")

Ett intervall på tio sekunder fungerar för ett batch som varar några minuter; för en körning över natten som bearbetar flera hundratusen rader, öka det till en minut eller mer. Högre pollningsprecision tillför inget värde där och ackumulerar bara onödiga API-anrop.

Ladda ner resultat

När statusen når SUCCESS exponerar jobbet en output_file som du laddar ner och parser rad för rad:

import json

if completed_job.status == "SUCCESS":
    # Hämta ID för utdatafilen
    output_file_id = completed_job.output_file

    # Ladda ner innehållet
    result_data = client.files.download(file_id=output_file_id)

    # Parsa JSONL-resultat
    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

    # Visa ett exempel
    for cid, resp in list(results.items())[:3]:
        content = resp["body"]["choices"][0]["message"]["content"]
        print(f"\n--- {cid} ---")
        print(content[:200])

Resultatfilen är också i JSONL-format, och varje rad bär på det ursprungliga custom_id tillsammans med modellens fullständiga svar. Här betalar sig namngivningsarbetet från föregående lektion: att indexera efter custom_id i en ordlista räcker för att stämma av svar mot dina källdokument, oavsett i vilken ordning de returneras. Att visa de tre första posterna trunkerade till 200 tecken är en användbar sanity check innan du börjar skriva till din databas.

Lista och hantera dina jobb

Du kan filtrera jobbinventariet efter status, vilket låter dig se vid varje givet tillfälle vad som faktiskt körs på ditt konto:

# Lista alla jobb som för närvarande körs
running_jobs = client.batch.jobs.list(status="RUNNING")
for j in running_jobs.data:
    print(f"Jobb {j.id} - Modell: {j.model} - Skapad: {j.created_at}")

Och när ett jobb drar ut på tiden eller du upptäcker ett promptfel efter inskickning, undviker avbrott att du betalar för onödig bearbetning:

# Avbryt ett jobb som tar för lång tid
client.batch.jobs.cancel(job_id="job-abc123")

Avbrott är asynkront: statusen går först till CANCELLATION_REQUESTED, och sedan till CANCELLED när stoppet är effektivt. Betrakta inte resursen som frigjord omedelbart när anropet returnerar.

End-to-end-arbetsflöde

Sammansatta bildar dessa fyra steg ett kort skript som du kan placera direkt i en schemaläggare:

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

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

# 1. Ladda upp filen
with open("batch_requests.jsonl", "rb") as f:
    batch_file = client.files.upload(
        file={"file_name": "batch_requests.jsonl", "content": f},
        purpose="batch"
    )

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

# 3. Vänta på slutförande
completed = wait_for_batch(client, job.id)

# 4. Ladda ner och parsar resultat
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"Batch misslyckades: {completed.status}")

Återanvänd detta skelett på din egen korpus med bara tio rader: du kommer att validera hela kedjan på några minuter innan du binder dig till full volym.

Viktiga punkter

  • Skapa ett batchjobb med client.batch.jobs.create() genom att ange fil, modell och endpoint
  • Sju möjliga statusar, inklusive tre terminala: SUCCESS, FAILED, CANCELLED
  • Pollning med ett intervall är standardmönstret för att spåra framsteg
  • Resultat är i JSONL-format, länkade till förfrågningar via custom_id
  • Du kan lista, inspektera och avbryta dina jobb när som helst