Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Apstrāde kļūdu un HTTP kodu

Nodarbība 12 no 22 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Apstrāde kļūdu un HTTP kodu
  2. OpenAI API HTTP kodi
  3. Visaptverošs kļūdu apstrādātājs
  4. Responses API specifiskas kļūdas
  5. Strukturēta kļūdu reģistrēšana
  6. Kopsavilkuma tabula
  7. Galvenās atziņas

Atjaunināts 2026. gada 3. novembrī, pamatojoties uz OpenAI dokumentāciju: parametri temperature un top_p tiek pieņemti tikai tad, ja spriešanas piepūle (reasoning effort) ir iestatīta uz none, savukārt GPT-5.6 modeļi pēc noklusējuma veic spriešanu (medium). Tādēļ izsaukumos, kuros ir norādīti šie parametri, ir jāprecizē reasoning={"effort": "none"} (Responses API) vai reasoning_effort="none" (Chat Completions). Avoti: GPT-6 izmantošana · GPT-5.6 Terra.

Precizēts 2026. gada 3. novembrī, pamatojoties uz OpenAI lapu Deprecations: iepriekš izmantotais noņemto modeļu piemērs izmantoja gpt-4o, kas joprojām ir pieejams līdz 2027. gada 14. janvārim; tagad tajā izmantots gpt-4-turbo, kas tika pārtraukts 2026. gada 23. oktobrī (norādītā aizstājējversija: gpt-5.6-sol). Avots: Deprecations.

Apstrāde kļūdu un HTTP kodu

Produkcijas vidē kļūdas ir neizbēgamas. Tīkls pazūd, API atslēga beidzas, kolēģis izvieto nederīgu parametru vai pašam API rodas trīs minūšu pārtraukums. Lai izveidotu stabilas lietotnes, ir būtiski saprast API atgrieztos HTTP kodus un pareizi ar tiem rīkoties. Visa izaicinājuma būtība slēpjas vienā jautājumā, kas tev jāuzdod par katru izņēmumu: vai tas pazudīs, ja mēģināsi vēlreiz, vai arī tu bezgalīgi riņķosi ap problēmu, ko var atrisināt tikai cilvēks?

OpenAI API HTTP kodi

API atgriež standarta HTTP kodus, lai norādītu katra pieprasījuma rezultātu. Python SDK neļauj tev šos kodus apstrādāt manuāli; tā vietā tas pārvērš katru no tiem tipētā izņēmumā, ko vari pārtvert atsevišķi. Tas ļauj rakstīt precīzus except blokus, nevis visaptverošu except Exception, kas aizsegtu problēmas patieso dabu.

from openai import OpenAI
from openai import (
    APIError,
    AuthenticationError,
    BadRequestError,
    RateLimitError,
    APIConnectionError,
    InternalServerError,
    PermissionDeniedError,
    NotFoundError,
    UnprocessableEntityError,
)

client = OpenAI()

401 — AuthenticationError

Kods 401 norāda, ka API atslēga ir nederīga vai trūkst. Parasti to redzi pirmās izvietošanas laikā, kad vides mainīgais nav nodots konteineram. Atkārtoti mēģināt ir bezjēdzīgi: atslēga būs tikpat nederīga arī pēc desmit sekundēm.

try:
    # Nederīga vai trūkstoša API atslēga
    bad_client = OpenAI(api_key="sk-invalid")
    bad_client.responses.create(
        model="gpt-5.6-terra",
        input="Test"
    )
except AuthenticationError as e:
    print(f"Code: {e.status_code}")  # 401
    print(f"Message: {e.message}")
    # Darbība: pārbaudi API atslēgu, vajadzības gadījumā ģenerē jaunu

400 — BadRequestError

Kods 401 norāda, ka pieprasījums ir nekorekti noformēts. Šeit ir norādīta temperatūra 5.0, lai gan maksimālā pieļaujamā vērtība ir 2.0. Kļūdas ziņojums gandrīz vienmēr nosauc bojāto parametru, padarot šo par ātrāk labojamo kļūdu – ja vien tu to pareizi reģistrē, nevis klusi ignorē.

try:
    # Nederīgi parametri
    client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature prasa effort none
        input="Test",
        temperature=5.0  # Nederīga vērtība (maks. 2.0)
    )
except BadRequestError as e:
    print(f"Code: {e.status_code}")  # 400
    print(f"Message: {e.message}")
    # Darbība: labo pieprasījuma parametrus

429 — RateLimitError

Kods 429 norāda, ka sūti pārāk daudz pieprasījumu vai esi pārsniedzis savu kvotu. Atšķirībā no iepriekšējiem diviem, šī kļūda pēc būtības ir pagaidu: skaitītājs tiek atiestatīts. Šis ir grāmatas piemērs atkārtotam mēģinājumam, taču tādam, kas gaida – un ar katru mēģinājumu gaida arvien ilgāk.

try:
    # Pārāk daudz pieprasījumu vai kvota pārsniegta
    client.responses.create(
        model="gpt-5.6-terra",
        input="Test"
    )
except RateLimitError as e:
    print(f"Code: {e.status_code}")  # 429
    print(f"Message: {e.message}")
    # Darbība: pagaidi un mēģini vēlreiz ar eksponenciālu atkāpšanos

500/503 — InternalServerError

Kļūdas 500 un 503 nāk no OpenAI, nevis no tevis. Tavs pieprasījums bija derīgs; infrastruktūra vienkārši nevarēja to apstrādāt. Mēģini vēlreiz pēc kavējuma: lielākajā daļā gadījumu otrais vai trešais mēģinājums ir veiksmīgs.

try:
    client.responses.create(
        model="gpt-5.6-terra",
        input="Test"
    )
except InternalServerError as e:
    print(f"Code: {e.status_code}")  # 500 vai 503
    print(f"Message: {e.message}")
    # Darbība: mēģini vēlreiz pēc kavējuma; kļūda ir OpenAI pusē

Visaptverošs kļūdu apstrādātājs

Apvienosim šīs darbības vienā funkcijā. Loģika ir triāža: fatālas kļūdas tiek pārvērstas par RuntimeError un izraisītas nekavējoties, pārejošas kļūdas izraisa gaidīšanu, kas ar katru ciklu dubultojas, un, ja mēģinājumu limits ir izsmelts, izsaukums beidzas tīri, nevis atgriež tukšu vērtību, ko izsaucošais kods varētu nepareizi interpretēt.

from openai import OpenAI, APIError, AuthenticationError, RateLimitError
from openai import BadRequestError, APIConnectionError, InternalServerError
import time

client = OpenAI()

def robust_api_call(prompt: str, model: str = "gpt-5.6-terra",
                    max_retries: int = 3) -> str:
    """API izsaukums ar visaptverošu kļūdu apstrādi."""

    for attempt in range(max_retries):
        try:
            response = client.responses.create(
                model=model,
                input=prompt
            )
            return response.output_text

        except AuthenticationError:
            # Nemēģini vēlreiz — atslēga ir nederīga
            raise RuntimeError("Nederīga API atslēga. Pārbaudi OPENAI_API_KEY.")

        except BadRequestError as e:
            # Nemēģini vēlreiz — pieprasījums ir nekorekts
            raise RuntimeError(f"Nederīgs pieprasījums: {e.message}")

        except RateLimitError:
            # Mēģini vēlreiz ar eksponenciālu atkāpšanos
            delay = 2 ** attempt
            print(f"Sasniegts ātruma limits. Gaidu {delay}s...")
            time.sleep(delay)

        except InternalServerError:
            # Mēģini vēlreiz — servera puses kļūda
            delay = 2 ** attempt
            print(f"Servera kļūda. Mēģinājums {attempt + 1}/{max_retries}...")
            time.sleep(delay)

        except APIConnectionError:
            # Mēģini vēlreiz — tīkla problēma
            delay = 2 ** attempt
            print(f"Savienojuma kļūda. Mēģinājums {attempt + 1}/{max_retries}...")
            time.sleep(delay)

    raise RuntimeError(f"Neizdevās pēc {max_retries} mēģinājumiem")

# Lietošana
try:
    result = robust_api_call("Hello!")
    print(result)
except RuntimeError as e:
    print(f"Fatāla kļūda: {e}")

Responses API specifiskas kļūdas

Divas situācijas ir pelnījušas atsevišķu attieksmi, jo tās parādās zem vispārīga koda, taču prasa ļoti specifisku risinājumu.

Konteksts ir pārāk garš

Uzvedne (prompt), kas pārsniedz konteksta logu, atgriež 400, tāpat kā kļūda parametra rakstībā. Lai atšķirtu šīs divas situācijas, pārbaudi ziņojumu: frāzes context_length_exceeded klātbūtne norāda, ka teksts ir jāsaīsina vai jāpāriet uz modeli ar lielāku konteksta logu, nevis jāpārskata tavi parametri.

try:
    response = client.responses.create(
        model="gpt-5.6-terra",
        input="x " * 300000  # Pārsniedz konteksta logu
    )
except BadRequestError as e:
    if "context_length_exceeded" in str(e.message):
        print("Uzvedne ir pārāk gara šim modelim.")
        print("Risinājumi: saīsini tekstu vai pārej uz modeli")
        print("ar lielāku konteksta logu.")

Modelis nav pieejams

Modeļu identifikatori nav mūžīgi. Izvietošana, kas joprojām atsaucas uz izņemtu modeli, neizdodas ar 404, liekot visai lietotnei sabrukt, lai gan iepriekšējā dienā tā strādāja. Apstrādā šo gadījumu eksplicīti: tas ir automātisks atgādinājums atjaunināt konfigurāciju.

try:
    response = client.responses.create(
        model="gpt-4-turbo",  # izņemts no API 2026. gada 23. oktobrī
        input="Test"
    )
except NotFoundError as e:
    print(f"Modelis nav atrasts: {e.message}")
    print("Izmanto gpt-5.6-sol, OpenAI norādīto aizstājēju, vai jaunāku modeli.")

Strukturēta kļūdu reģistrēšana

Nereģistrēta kļūda ir tāda, par kuru uzzināsi tikai no klienta iesniegtas biļetes. Reģistrēšana JSON formātā, nevis brīvā tekstā, maina visu, kad nepieciešama agregācija: vari saskaitīt 429 kļūdas stundā, filtrēt pēc response_id vai izsekot patēriņa novirzēm, kas nav iespējams ar manuāli rakstītām žurnāla rindām.

import logging
import json
from datetime import datetime

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("openai_client")

def call_with_log(prompt: str) -> str:
    """API izsaukums ar strukturētu reģistrēšanu."""
    request_id = None

    try:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=prompt
        )

        logger.info(json.dumps({
            "event": "api_success",
            "model": response.model,
            "tokens": response.usage.total_tokens,
            "response_id": response.id,
            "timestamp": datetime.now().isoformat()
        }))

        return response.output_text

    except APIError as e:
        logger.error(json.dumps({
            "event": "api_error",
            "status_code": e.status_code,
            "message": e.message,
            "timestamp": datetime.now().isoformat()
        }))
        raise

result = call_with_log("Hello!")

Kopsavilkuma tabula

Paturiet šo režģi pa rokai: tajā apkopots lēmums, kas jāpieņem katram kodam.

KodsIzņēmumsMēģināt vēlreiz?Darbība
400BadRequestErrorNēLabo pieprasījumu
401AuthenticationErrorNēPārbaudi API atslēgu
403PermissionDeniedErrorNēPārbaudi atļaujas
404NotFoundErrorNēPārbaudi modeli/beigu punktu
422UnprocessableEntityErrorNēLabo formātu
429RateLimitErrorJāEksponenciāla atkāpšanās
500InternalServerErrorJāPagaidi un mēģini vēlreiz
503InternalServerErrorJāPakalpojums uz laiku nav pieejams

Galvenās atziņas

  • Klasificē kļūdas: atkārtoti mēģināmas (429, 500, 503) pretstatā fatālām (400, 401, 403)
  • Atkārtoti mēģināmām kļūdām izmanto eksponenciālu atkāpšanos
  • Nekad nemēģini vēlreiz autentifikācijas vai nederīga pieprasījuma kļūdu gadījumā
  • Reģistrē katru kļūdu ar kontekstu (kods, ziņojums, laika zīmogs)
  • SDK automātiski veic 2 atkārtotus mēģinājumus – konfigurē max_retries, ja nepieciešams