Salt la conținutul principal
Română— Alege o limbă
Meniu

asyncio.gather pentru procesarea în loturi

Lecția 5 din 12 Actualizată 30 iulie 2026 Avansat
Pe această pagină
  1. Orchestarea cererilor paralele
  2. Sintaxa de bază
  3. Model complet: Lot cu semafor
  4. Gestionarea erorilor într-un lot
  5. Divizarea în sub-loturi (Chunking)
  6. Urmărirea progresului
  7. Puncte cheie

Orchestarea cererilor paralele

asyncio.gather este funcția centrală pentru executarea mai multor coroutine în paralel și colectarea tuturor rezultatelor. Combinată cu un semafor, vă permite să procesați loturi de cereri eficient, respectând în același timp limitele API-ului.

Sintaxa de bază

import asyncio

requests = ["Question 1", "Question 2", "Question 3"]
tasks = [process_request(r) for r in requests]
responses = await asyncio.gather(*tasks)

asyncio.gather primește un număr variabil de coroutine (de aici utilizarea *tasks pentru a despacheta lista) și returnează o listă de rezultate în aceeași ordine ca și task-urile submitate. Acesta este un punct important: chiar dacă întrebarea 3 se finalizează înaintea întrebării 1, responses[0] va conține întotdeauna rezultatul pentru întrebarea 1.

Model complet: Lot cu semafor

Iată modelul pe care îl veți utiliza cel mai des în producție:

import os
from asyncio import Semaphore
from openai import AsyncOpenAI
import httpx

client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0)
)

async def process_batch(prompts: list[str], max_concurrent: int = 5) -> list[str]:
    sem = Semaphore(max_concurrent)

    async def single_request(prompt: str) -> str:
        async with sem:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content

    tasks = [single_request(p) for p in prompts]
    return await asyncio.gather(*tasks)

Acest model încapsulează semaforul în interiorul funcției de lot. Trebuie doar să apelați process_batch(prompts) și să recuperați lista de răspunsuri.

Gestionarea erorilor într-un lot

Implicit, dacă o singură coroutine aruncă o excepție, asyncio.gather anulează totul și propagă eroarea. Parametrul return_exceptions=True modifică acest comportament:

async def safe_batch(prompts: list[str]) -> list[str | Exception]:
    sem = Semaphore(5)

    async def single_request(prompt: str) -> str:
        async with sem:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content

    tasks = [single_request(p) for p in prompts]
    results = await asyncio.gather(*tasks, return_exceptions=True)
    return results

# Utilizare
results = await safe_batch(mes_prompts)
for i, result in enumerate(results):
    if isinstance(result, Exception):
        print(f"Error on prompt {i}: {result}")
    else:
        print(f"Result {i}: {result[:100]}...")

Cu return_exceptions=True, erorile sunt capturate ca valori în lista de rezultate. Puteți apoi să identificați și să reîncercați cererile eșuate.

Divizarea în sub-loturi (Chunking)

Pentru volume foarte mari, este mai bine să divizați în sub-loturi decât să lansați mii de task-uri simultan:

async def chunked_batch(
    prompts: list[str],
    chunk_size: int = 50,
    max_concurrent: int = 5
) -> list[str]:
    all_results = []

    for i in range(0, len(prompts), chunk_size):
        chunk = prompts[i:i + chunk_size]
        print(f"Processing batch {i//chunk_size + 1} ({len(chunk)} prompts)")
        results = await process_batch(chunk, max_concurrent)
        all_results.extend(results)

    return all_results

Divizarea în chunk-uri oferă mai multe avantaje: puteți afișa progresul, salva rezultate intermediare și limita utilizarea memoriei. Dacă un sub-lot eșuează, nu pierdeți rezultatele din sub-loturile anterioare.

Urmărirea progresului

Pentru loturi mari, un indicator de progres este util:

import asyncio
from asyncio import Semaphore

async def batch_with_progress(prompts: list[str], max_concurrent: int = 5) -> list[str]:
    sem = Semaphore(max_concurrent)
    completed = 0
    total = len(prompts)

    async def single_request(prompt: str) -> str:
        nonlocal completed
        async with sem:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            completed += 1
            print(f"\r{completed}/{total} completed", end="", flush=True)
            return response.choices[0].message.content

    tasks = [single_request(p) for p in prompts]
    results = await asyncio.gather(*tasks)
    print()  # linie nouă după progres
    return results

Puncte cheie

  • asyncio.gather(*tasks) execută coroutine în paralel și returnează rezultatele în ordinea originală
  • return_exceptions=True previne ca o singură eroare să eșueze întregul lot
  • Divizarea în chunk-uri vă permite să gestionați volume foarte mari fără a satura memoria
  • Combinați întotdeauna gather cu un semafor pentru a respecta limitele de rată
  • Adăugați urmărirea progresului pentru procesele de lungă durată