Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Spracovanie chýb a HTTP kódy

Lekcia 12 z 22 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Spracovanie chýb a HTTP kódy
  2. HTTP kódy API OpenAI
  3. Komplexný obsluhovač chýb
  4. Špecifické chyby Responses API
  5. Štruktúrované logovanie chýb
  6. Súhrnná tabuľka
  7. Kľúčové poznatky

Aktualizované 3. novembra 2026 na základe dokumentácie OpenAI: parametre temperature a top_p sú akceptované len pri úsilí o logické usudzovanie (reasoning effort) nastavenom na none, zatiaľ čo modely GPT-5.6 predvolene logicky usudzujú (medium). Volania, ktoré nastavujú tieto parametre, preto musia špecifikovať reasoning={"effort": "none"} (Responses API) alebo reasoning_effort="none" (Chat Completions). Zdroje: Používanie GPT-6 · GPT-5.6 Terra.

Objasnené 3. novembra 2026 na základe stránky Deprecations od OpenAI: odstránený príklad modelu predtým používal gpt-4o, ktorý zostáva dostupný do 14. januára 2027; teraz používa gpt-4-turbo, ktorý bol ukončený 23. októbra 2026 (označená náhrada: gpt-5.6-sol). Zdroj: Deprecations.

Spracovanie chýb a HTTP kódy

V produkčnom prostredí sú chyby nevyhnutné. Sieť vypadne, API kľúč vyprší, kolega nasadí neplatný parameter alebo samotné API má trojminútový výpadok. Pochopenie HTTP kódov, ktoré API vracia, a ich správne spracovanie je kľúčové pre budovanie robustných aplikácií. Celá výzva sa redukuje na jednu otázku, ktorú si musíš položiť pri každej výnimke: zmizne táto chyba, ak to skúsim znova, alebo budem donekonečna循环ovať nad problémom, ktorý dokáže vyriešiť len človek?

HTTP kódy API OpenAI

API vracia štandardné HTTP kódy, ktoré indikujú výsledok každej požiadavky. Python SDK ti neumožňuje spracovávať tieto kódy manuálne; namiesto toho každý z nich prekladá na typovanú výnimku, ktorú môžeš zachytiť samostatne. To ti umožňuje písať presné bloky except namiesto všeobecného except Exception, ktorý by zahmlil podstatu problému.

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

client = OpenAI()

401 — AuthenticationError

Kód 401 znamená, že API kľúč je neplatný alebo chýba. Toto zvyčajne uvidíš pri prvom nasadení, keď sa premenná prostredia nepreniesla do kontajnera. Opakovanie pokusu je zbytočné: o desať sekúnd bude kľúč rovnako neplatný.

try:
    # Neplatný alebo chýbajúci API kľúč
    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}")
    # Akcia: over API kľúč, v prípade potreby ho regeneruj

400 — BadRequestError

Kód 400 ti hovorí, že požiadavka je chybná. Tu je napríklad poskytnutá hodnota temperature 5.0, hoci maximálna akceptovaná hodnota je 2.0. Chybová hláška takmer vždy pomenuje chybný parameter, čo z tejto chyby robí tú najrýchlejšie opraviteľnú – za predpokladu, že ju správne zaznamenáš do logu a nebudeš ju ticho ignorovať.

try:
    # Neplatné parametre
    client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature vyžaduje effort none
        input="Test",
        temperature=5.0  # Neplatná hodnota (max 2.0)
    )
except BadRequestError as e:
    print(f"Code: {e.status_code}")  # 400
    print(f"Message: {e.message}")
    # Akcia: oprav parametre požiadavky

429 — RateLimitError

Kód 429 znamená, že odosielaš príliš veľa požiadaviek alebo si prekročil svoju kvótu. Na rozdiel od predchádzajúcich dvoch je táto chyba svojou povahou dočasná: počítadlo sa resetuje. Toto je učebnicový prípad pre opakovanie pokusu, ale takého, ktorý čaká – a s každým pokusom čaká dlhšie.

try:
    # Príliš veľa požiadaviek alebo prekročená kvóta
    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}")
    # Akcia: počkaj a skús znova s exponenciálnym oneskorením

500/503 — InternalServerError

Chyby 500 a 503 prichádzajú od OpenAI, nie od teba. Tvoja požiadavka bola platná; infraštruktúra ju jednoducho nedokázala spracovať. Skús to znova po oneskorení: vo veľkej väčšine prípadov druhý alebo tretí pokus uspeje.

try:
    client.responses.create(
        model="gpt-5.6-terra",
        input="Test"
    )
except InternalServerError as e:
    print(f"Code: {e.status_code}")  # 500 alebo 503
    print(f"Message: {e.message}")
    # Akcia: skús znova po oneskorení; chyba je na strane OpenAI

Komplexný obsluhovač chýb

Poďme spojiť tieto správania do jednej funkcie. Logika je triáž: fatálne chyby sa prevedú na RuntimeError a okamžite sa vyvolajú, prechodné chyby spustia čakanie, ktoré sa s každým kolom zdvojnásobí, a ak sa vyčerpá rozpočet pokusov, volanie zlyhá čisto, namiesto toho, aby vrátilo prázdnu hodnotu, ktorú by volajúci mohol nesprávne interpretovať.

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:
    """Volanie API s komplexným spracovaním chýb."""

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

        except AuthenticationError:
            # Neopakuj — kľúč je neplatný
            raise RuntimeError("Neplatný API kľúč. Skontroluj OPENAI_API_KEY.")

        except BadRequestError as e:
            # Neopakuj — požiadavka je chybná
            raise RuntimeError(f"Neplatná požiadavka: {e.message}")

        except RateLimitError:
            # Opakuj s exponenciálnym oneskorením
            delay = 2 ** attempt
            print(f"Dosiahnutý limit rýchlosti. Čakám {delay}s...")
            time.sleep(delay)

        except InternalServerError:
            # Opakuj — chyba na strane servera
            delay = 2 ** attempt
            print(f"Chyba servera. Pokus {attempt + 1}/{max_retries}...")
            time.sleep(delay)

        except APIConnectionError:
            # Opakuj — problém so sieťou
            delay = 2 ** attempt
            print(f"Chyba pripojenia. Pokus {attempt + 1}/{max_retries}...")
            time.sleep(delay)

    raise RuntimeError(f"Zlyhanie po {max_retries} pokusoch")

# Použitie
try:
    result = robust_api_call("Ahoj!")
    print(result)
except RuntimeError as e:
    print(f"Fatálna chyba: {e}")

Špecifické chyby Responses API

Dve situácie si zasluhujú samostatné zaobchádzanie, pretože sa objavujú pod všeobecným kódom, ale vyžadujú si veľmi špecifickú opravu.

Kontext je príliš dlhý

Prompt, ktorý presahuje okno kontextu, vráti kód 400, rovnako ako preklep v parametri. Aby si rozlíšil tieto dva prípady, preskúmaj hlášku: prítomnosť context_length_exceeded ťa nasmeruje skôr k orezaniu textu alebo prepnutiu na model s väčším oknom kontextu, než k revízii tvojich parametrov.

try:
    response = client.responses.create(
        model="gpt-5.6-terra",
        input="x " * 300000  # Presahuje okno kontextu
    )
except BadRequestError as e:
    if "context_length_exceeded" in str(e.message):
        print("Prompt je pre tento model príliš dlhý.")
        print("Riešenia: orež text alebo prepnite na model")
        print("s väčším oknom kontextu.")

Model nie je dostupný

Identifikátory modelov nie sú večné. Nasadenie, ktoré stále odkazuje na vyradený model, zlyhá s kódom 404, čo spôsobí pád celej aplikácie, hoci deň predtým fungovala. Tento prípad ošetri explicitne: je to automatická pripomienka aktualizovať tvoju konfiguráciu.

try:
    response = client.responses.create(
        model="gpt-4-turbo",  # vyradené z API 23. októbra 2026
        input="Test"
    )
except NotFoundError as e:
    print(f"Model nenájdený: {e.message}")
    print("Použi gpt-5.6-sol, náhradu označenú OpenAI, alebo novší model.")

Štruktúrované logovanie chýb

Chyba, ktorá nie je zaznamenaná v logu, je chyba, ktorú objavíš až cez tiket od zákazníka. Logovanie v JSON namiesto voľného textu mení všetko, keď potrebuješ agregovať údaje: môžeš počítať chyby 429 za hodinu, filtrovať podľa response_id alebo sledovať drift spotreby, čo je pri ručne písaných riadkoch logu nemožné.

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:
    """Volanie API so štruktúrovaným logovaním."""
    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("Ahoj!")

Súhrnná tabuľka

Maj túto mriežku po ruke: zhrnuje rozhodnutie, ktoré musíš urobiť pre každý kód.

KódVýnimkaOpakovať?Akcia
400BadRequestErrorNieUprav požiadavku
401AuthenticationErrorNieSkontroluj kľúč API
403PermissionDeniedErrorNieSkontroluj oprávnenia
404NotFoundErrorNieSkontroluj model/endpoint
422UnprocessableEntityErrorNieUprav formát
429RateLimitErrorÁnoExponenciálne oneskorenie
500InternalServerErrorÁnoPočkaj a skús znova
503InternalServerErrorÁnoSlužba je dočasne nedostupná

Kľúčové poznatky

  • Kategorizuj chyby: opakovateľné (429, 500, 503) vs fatálne (400, 401, 403)
  • Pre opakovateľné chyby použi exponenciálne oneskorenie
  • Nikdy neopakuj chyby autentifikácie alebo neplatnej požiadavky
  • Loguj každú chybu s kontextom (kód, správa, časová pečiatka)
  • SDK automaticky vybaví 2 opakovania – v prípade potreby nakonfiguruj max_retries