asyncio.gather pentru procesarea în loturi
Pe această pagină
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=Trueprevine 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
gathercu un semafor pentru a respecta limitele de rată - Adăugați urmărirea progresului pentru procesele de lungă durată