asyncio.gather pro dávkové zpracování
Na této stránce
Orchestrování paralelních požadavků
asyncio.gather je klíčová funkce pro paralelní spouštění více korutin a sběr všech výsledků. V kombinaci se semaforem ti umožňuje efektivně zpracovávat dávky požadavků při dodržení limitů API.
Základní syntaxe
import asyncio
requests = ["Question 1", "Question 2", "Question 3"]
tasks = [process_request(r) for r in requests]
responses = await asyncio.gather(*tasks)
asyncio.gather přijímá proměnný počet korutin (proto se používá *tasks pro rozbalení seznamu) a vrací seznam výsledků ve stejném pořadí, v jakém byly úlohy odeslány. To je důležitý bod: i když se otázka 3 dokončí dříve než otázka 1, responses[0] bude vždy obsahovat výsledek pro otázku 1.
Kompletní vzor: Dávka se semaforem
Zde je vzor, který budeš v produkčním prostředí používat nejčastěji:
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)
Tento vzor zapouzdřuje semafor uvnitř funkce pro dávku. Stačí pouze zavolat process_batch(prompts) a získat seznam odpovědí.
Zpracování chyb v dávce
Ve výchozím nastavení, pokud jedna korutina vyvolá výjimku, asyncio.gather vše zruší a chybu propaguje dál. Parametr return_exceptions=True toto chování mění:
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
# Použití
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]}...")
S return_exceptions=True jsou chyby zachyceny jako hodnoty v seznamu výsledků. Následně můžeš identifikovat a opakovat neúspěšné požadavky.
Rozdělení na poddávky (Chunking)
Při velmi velkých objemech je lepší rozdělit práci na poddávky, než spouštět tisíce úloh najednou:
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
Rozdělení na části (chunking) nabízí několik výhod: můžeš zobrazovat průběh, ukládat průběžné výsledky a omezit využití paměti. Pokud selže jedna poddávka, nepřijdeš o výsledky z předchozích poddávek.
Sledování průběhu
U velkých dávek je užitečný indikátor průběhu:
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() # nový řádek po dokončení průběhu
return results
Klíčové poznatky
asyncio.gather(*tasks)spouští korutiny paralelně a vrací výsledky v původním pořadíreturn_exceptions=Truezabraňuje tomu, aby jedna chyba selhala celou dávku- Rozdělení na části (chunking) ti umožňuje zpracovávat velmi velké objemy bez zahlcení paměti
- Vždy kombinuj
gatherse semaforem pro dodržení limitů rychlosti (rate limits) - Pro dlouho běžící procesy přidej sledování průběhu