Apstrāde kļūdu un HTTP kodu
Šajā lapā
Atjaunināts 2026. gada 3. novembrī, pamatojoties uz OpenAI dokumentāciju: parametri
temperatureuntop_ptiek pieņemti tikai tad, ja spriešanas piepūle (reasoning effort) ir iestatīta uznone, 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) vaireasoning_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ā izmantotsgpt-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.
| Kods | Izņēmums | Mēģināt vēlreiz? | Darbība |
|---|---|---|---|
| 400 | BadRequestError | Nē | Labo pieprasījumu |
| 401 | AuthenticationError | Nē | Pārbaudi API atslēgu |
| 403 | PermissionDeniedError | Nē | Pārbaudi atļaujas |
| 404 | NotFoundError | Nē | Pārbaudi modeli/beigu punktu |
| 422 | UnprocessableEntityError | Nē | Labo formātu |
| 429 | RateLimitError | Jā | Eksponenciāla atkāpšanās |
| 500 | InternalServerError | Jā | Pagaidi un mēģini vēlreiz |
| 503 | InternalServerError | Jā | 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