asyncio.gather eräprosessointia varten
Tällä sivulla
Rinnakkaisten pyyntöjen orkestrointi
asyncio.gather on ydinfunktio useiden korutiinien suorittamiseen rinnakkain ja kaikkien tulosten keräämiseen. Yhdistettynä semaforiin sen avulla voit käsitellä pyyntöeriä tehokkaasti noudattaen samalla API-rajoituksia.
Perussyntaksi
import asyncio
requests = ["Question 1", "Question 2", "Question 3"]
tasks = [process_request(r) for r in requests]
responses = await asyncio.gather(*tasks)
asyncio.gather ottaa vastaan vaihtelevan määrän korutiineja (minkä vuoksi käytetään *tasks-purkua listalle) ja palauttaa tulosten listan samassa järjestyksessä kuin tehtävät lähetettiin. Tämä on tärkeä seikka: vaikka kysymys 3 valmistuisi ennen kysymystä 1, responses[0] sisältää aina kysymyksen 1 tuloksen.
Täydellinen malli: Erä semaforilla
Tässä on malli, jota tulet käyttämään useimmiten tuotantoympäristössä:
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)
Tämä malli kapseloi semaforin eräfunktion sisälle. Sinun tarvitsee vain kutsua process_batch(prompts) ja hakea vastauslista.
Virheiden käsittely erässä
Oletusarvoisesti, jos yksittäinen korutiini nostaa poikkeuksen, asyncio.gather peruuttaa kaiken ja välittää virheen eteenpäin. Parametri return_exceptions=True muuttaa tätä käyttäytymistä:
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
# Käyttö
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]}...")
Kun käytät parametria return_exceptions=True, virheet tallennetaan arvoina tulosten listaan. Tämän jälkeen voit tunnistaa epäonnistuneet pyynnöt ja yrittää niitä uudelleen.
Jakaminen osieriin (Chunking)
Hyvin suurissa määrissä on parempi jakaa pyynnöt osieriin kuin käynnistää tuhansia tehtäviä samanaikaisesti:
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
Osieriin jakamisella on useita etuja: voit näyttää edistymisen, tallentaa välituloksia ja rajoittaa muistin käyttöä. Jos yksi osierä epäonnistuu, et menetä aiempien osierien tuloksia.
Edistymisen seuranta
Suurissa erissä edistymisindikaattori on hyödyllinen:
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() # uusi rivi edistymisen jälkeen
return results
Keskeiset asiat
asyncio.gather(*tasks)suorittaa korutiinit rinnakkain ja palauttaa tulokset alkuperäisessä järjestyksessäreturn_exceptions=Trueestää yksittäisen virheen kaatamasta koko erää- Osieriin jakaminen mahdollistaa hyvin suurten määrien käsittelyn muistia kuormittamatta
- Yhdistä
gatheraina semaforiin nopeusrajoitusten noudattamiseksi - Lisää edistymisen seuranta pitkäkestoisiin prosesseihin