Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Cúlú Easpónantúil ar HTTP 429

Ceacht 6 as 12 Nuashonraithe 30 Iúil 2026 Ardleibhéal
Ar an leathanach seo
  1. Tuiscint a fháil ar an Earráid 429
  2. Conas a Oibríonn an Cúlú Easpónantúil
  3. Cur Chun Feidhte Láimhe
  4. An Leabharlann tenacity a Úsáid
  5. Cúlú agus Seimeafar a Chomhcheangal
  6. An Cúlú a Oiriúnú de Réir Cineáil Earráide
  7. Príomhphointí

Tuiscint a fháil ar an Earráid 429

Ciallaíonn earráid HTTP 429 go bhfuil tú tar éis teorainneacha ráta an API a shárú. Diúltaíonn freastalaí xAI d’iarratais go sealadach chun an bonneagar a chosaint. Is gnách an earráid seo i gcomhthéacs próiseála baisce: ní léiríonn sí ach go bhfuil tú ag seoladh iarratas ró-thapa.

Ní éirí as an obair an freagra cuí, ach fanacht sula ndéanann tú iarracht arís. Is é an cúlú easpónantúil an straitéis chaighdeánach chun an staid seo a láimhseáil.

Conas a Oibríonn an Cúlú Easpónantúil

In ionad iarracht a dhéanamh láithreach (rud a spreagfadh 429 eile), fanann tú méid ama atá ag méadú idir gach iarracht:

  • 1ú teip: fan 1 soicind
  • 2ú teip: fan 2 shoicind
  • 3ú teip: fan 4 shoicind
  • 4ú teip: fan 8 soicind
  • 5ú teip: éirí as

Déanann an mhoill dúbailt le gach iarracht, agus sin fáth a dtugtar “easpónantúil” air. Tugann sé seo am don fhreastalaí teacht ar ais chun toirte.

Cur Chun Feidhte Láimhe

import asyncio
import random
from openai import RateLimitError

async def request_with_backoff(
    prompt: str,
    max_retries: int = 5,
    base_delay: float = 1.0
) -> str:
    for attempt in range(max_retries):
        try:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content

        except RateLimitError:
            if attempt == max_retries - 1:
                raise  # last attempt, propagate the error

            delay = base_delay * (2 ** attempt)
            jitter = random.uniform(0, delay * 0.1)
            wait_time = delay + jitter

            print(f"Rate limit hit, attempt {attempt + 1}/{max_retries}. "
                  f"Waiting {wait_time:.1f}s")
            await asyncio.sleep(wait_time)

Tá an jitter (athrú randamach) tábhachtach. Má fhaigheann ilchóraitíní 429 ag an am céanna, gan jitter, dhéanfadh siad uile iarracht arís ag an nóiméad céanna go beacht, rud a spreagfadh 429 eile. Díshioncronaíonn an jitter na hiarrachtaí.

An Leabharlann tenacity a Úsáid

Chun críocha táirgeachta, simplíonn an leabharlann tenacity an cur chun feidhte:

from tenacity import (
    retry,
    stop_after_attempt,
    wait_exponential,
    retry_if_exception_type
)
from openai import RateLimitError

@retry(
    stop=stop_after_attempt(5),
    wait=wait_exponential(multiplier=1, min=1, max=60),
    retry=retry_if_exception_type(RateLimitError)
)
async def robust_request(prompt: str) -> str:
    response = await client.chat.completions.create(
        model="grok-4.5",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

Gabhann an maisiú @retry an RateLimitError, fanann sé moill easpónantúil (idir 1 agus 60 soicind), agus déanann sé iarracht arís suas le 5 huaire. Fanann cód na feidhme glan agus inléite.

Cúlú agus Seimeafar a Chomhcheangal

Go praiticiúil, comhcheanglaíonn tú an cúlú le seimeafar chun rialú iomlán a bheith agat:

async def resilient_batch(prompts: list[str], max_concurrent: int = 5) -> list[str]:
    sem = Semaphore(max_concurrent)

    async def single_request(prompt: str) -> str:
        async with sem:
            return await request_with_backoff(prompt)

    tasks = [single_request(p) for p in prompts]
    return await asyncio.gather(*tasks, return_exceptions=True)

Coscaíonn an seimeafar an t-API a ualú ró-mhór, agus láimhseálann an cúlú earráidí 429 iarmharacha. Is é an chosaint dhúbailte seo an chumraíocht a mholtar do tháirgeadh.

An Cúlú a Oiriúnú de Réir Cineáil Earráide

Ní dhéanann gach earráid údar le hiarracht arís. Seo aicmiú:

from openai import RateLimitError, APITimeoutError, APIConnectionError, BadRequestError

async def smart_retry(prompt: str, max_retries: int = 5) -> str:
    for attempt in range(max_retries):
        try:
            return await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
        except RateLimitError:
            delay = 2 ** attempt
            await asyncio.sleep(delay)
        except (APITimeoutError, APIConnectionError):
            delay = 2 ** attempt
            await asyncio.sleep(delay)
        except BadRequestError:
            raise  # error in prompt, retry useless

Tuilleann earráidí 429 (teorainn ráta), amcheisteanna, agus earráidí nascleanúna iarracht arís. Mar sin féin, ní réiteofar BadRequestError (prónt neamhbhailí) trí iarracht a dhéanamh arís.

Príomhphointí

  • Is gnách agus súilte earráid 429 le linn próiseála baisce
  • Déanann an cúlú easpónantúil an mhoill a dhúbailt idir gach iarracht (1s, 2s, 4s, 8s…)
  • Díshioncronaíonn an jitter iarrachtaí nua chun imbhuailtí a sheachaint
  • Simplíonn an leabharlann tenacity an cur chun feidhte i dtáirgeadh
  • Comhcheangail seimeafar agus cúlú i gcónaí don athléimneacht uasta
  • Ná déan iarracht arís ar earráidí iarratais neamhbhailí (BadRequestError)