Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

asyncio.gather għall-Ipproċċar f'Lotti

Lezzjoni 5 / 12 Aġġornat 30 ta’ Lulju 2026 Avvanzat
F'din il-paġna
  1. Orkestrazzjoni ta’ Talbiet Paralleli
  2. Sintassi Bażika
  3. Mudell Sħiħ: Lott b’Semaphore
  4. Ġestjoni tal-Iżbalji f’Lott
  5. Qsim f’Sottolotti (Chunking)
  6. Traċċar tal-Progress
  7. Punti Ewlenin

Orkestrazzjoni ta’ Talbiet Paralleli

asyncio.gather hija l-funzjoni ewlenija biex tħaddem ħafna coroutines flimkien u tiġbor ir-riżultati kollha. Meta tingħaqad ma’ semaphore, tippermettilek tipproċessa lotti ta’ talbiet b’mod effiċjenti filwaqt li tirrispetta l-limiti tal-API.

Sintassi Bażika

import asyncio

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

asyncio.gather tieħu numru varjabbli ta’ coroutines (għalhekk l-użu ta’ *tasks biex tiftaħ il-lista) u tirritorna lista ta’ riżultati bl-istess ordni bħall-kompiti sottomessi. Dan huwa punt importanti: anke jekk il-mistoqsija 3 tispiċċa qabel il-mistoqsija 1, responses[0] dejjem ikun fih ir-riżultat għall-mistoqsija 1.

Mudell Sħiħ: Lott b’Semaphore

Hawnhekk hawn il-mudell li se tuża l-aktar spiss fil-produzzjoni:

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)

Dan il-mudell jinkapsula s-semaphore fil-funzjoni tal-lott. Għandek biss bżonn issejjaħ process_batch(prompts) u tirrikupra l-lista ta’ risposti.

Ġestjoni tal-Iżbalji f’Lott

B’mod predefinit, jekk coroutine waħda tħajjar eċċezzjoni, asyncio.gather tikkanċella kollox u tippropaga l-iżball. Il-parametru return_exceptions=True ibiddel dan l-imġiba:

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

# Użu
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]}...")

B’return_exceptions=True, l-iżbalji jiġu maqbuda bħala valuri fil-lista tar-riżultati. Imbagħad tista’ tidentifika u terġa’ tipprova t-talbiet li fallew.

Qsim f’Sottolotti (Chunking)

Għal volumi kbar ħafna, huwa aħjar li taqsam f’sottolotti minflok ma tniedi eluf ta’ kompiti fl-istess ħin:

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

Il-”chunking” joffri diversi vantaġġi: tista’ turi l-progress, issalva riżultati intermedjarji, u tillimita l-użu tal-memorja. Jekk jifalli sottolott wieħed, ma titlefx ir-riżultati mis-sottolotti preċedenti.

Traċċar tal-Progress

Għal lotti kbar, indikatur tal-progress huwa utli:

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()  # linja ġdida wara l-progress
    return results

Punti Ewlenin

  • asyncio.gather(*tasks) iħaddem coroutines paralleli u jirritorna r-riżultati fl-ordni oriġinali
  • return_exceptions=True jipprevjeni li żball wieħed ifalli l-lott kollu
  • Il-”chunking” jippermettilek tittratta volumi kbar ħafna mingħajr ma tissatura l-memorja
  • Dejjem għaqqad gather ma’ semaphore biex tirrispetta l-limiti tar-rata
  • Żid traċċar tal-progress għal proċessi li jieħdu żmien twil