asyncio.gather rühmtöötluseks
Sellel lehel
Paralleelsete päringute orkestreerimine
asyncio.gather on põhifunktsioon mitme korutiini paralleelseks käivitamiseks ja kõigi tulemuste kogumiseks. Koos semaforiga kasutades saad tõhusalt töödelda päringute pakette, austades samal ajal API piiranguid.
Põhisüntaks
import asyncio
requests = ["Question 1", "Question 2", "Question 3"]
tasks = [process_request(r) for r in requests]
responses = await asyncio.gather(*tasks)
asyncio.gather võtab vastu muutuva arvu korutiine (seetõttu kasutatakse loendi lahti pakkimiseks *tasks) ja tagastab tulemuste loendi samas järjekorras, nagu ülesanded esitati. See on oluline punkt: isegi kui küsimus 3 lõpeb enne küsimust 1, sisaldab responses[0] alati tulemust küsimusele 1.
Täielik muster: Pakett koos semaforiga
Siin on muster, mida kasutad tootmiskeskkonnas kõige sagedamini:
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)
See muster kapseldab semafori paketi funktsiooni sisse. Sul tuleb lihtsalt kutsuda process_batch(prompts) ja saada vastuste loend.
Vigade käsitlemine paketis
Vaikimisi, kui üksainus korutiin viskab erindi, tühistab asyncio.gather kõik ja levitab vea edasi. Parameeter return_exceptions=True muudab seda käitumist:
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
# Kasutamine
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]}...")
Kasutades return_exceptions=True, salvestatakse vead tulemuste loendis väärtustena. Seejärel saad tuvastada ebaõnnestunud päringud ja need uuesti proovida.
Alam-pakkettideks jagamine (tükeldamine)
Väga suurte mahtude korral on parem jagada töö alam-pakkettideks, mitte käivitada tuhandeid ülesandeid samaaegselt:
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
Tükeldamisel on mitu eelist: saad kuvada edenemist, salvestada vahepealseid tulemusi ja piirata mälukasutust. Kui üks alampakkett ebaõnnestub, ei kaota sa eelmiste alampakkettide tulemusi.
Edenemise jälgimine
Suurte pakkettide puhul on kasulik edenemisnäitaja:
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() # uus rida pärast edenemist
return results
Peamised punktid
asyncio.gather(*tasks)käivitab korutiinid paralleelselt ja tagastab tulemused algses järjekorrasreturn_exceptions=Truehoiab ära olukorra, kus üksainus viga nurjab kogu paketi- Tükeldamine võimaldab hallata väga suuri mahte ilma mälu üle koormamata
- Kombineeri
gatheralati semaforiga, et austada kiirusepiiranguid - Lisa pikaajaliste protsesside jaoks edenemise jälgimine