Com resoldre el codi d'error de l'API OpenAI 429 a Python fins i tot amb crèdit

Entendre els errors de quota de l'API OpenAI

Quan es treballa amb l'API d'OpenAI, es reb un error com Codi d'error 429 pot ser frustrant, especialment per a aquells que són nous a Python i OpenAI. Aquest error normalment indica que heu superat la vostra quota d'ús de l'API actual.

Si heu comprovat el vostre compte d'OpenAI i heu confirmat que encara teniu crèdits disponibles, potser us preguntareu per què aquest error continua apareixent. És habitual que els desenvolupadors es trobin amb aquest problema quan configuren per primera vegada les seves trucades a l'API.

Entendre la causa d'aquest problema és crucial per assegurar-vos que podeu aprofitar l'API de manera eficaç. Aquesta guia desglossarà els motius probables de l'error i us proporcionarà els passos per resoldre'l.

Aprofundim en els possibles motius pels quals us trobeu amb aquest error, tot i que teniu crèdits al vostre compte d'OpenAI, i com abordar la solució al vostre script de Python.

Com els scripts de Python gestionen els límits de velocitat de l'API OpenAI

Els scripts proporcionats anteriorment estan dissenyats per abordar un problema comú que s'enfronten els desenvolupadors quan utilitzen l'API d'OpenAI: trobar un missatge d'error que indica que heu superat el vostre Quota de l'API tot i tenir crèdit. Aquest problema està relacionat amb el límit tarifari imposat per OpenAI al nombre de sol·licituds en un període determinat. L'script principal s'escriu per gestionar aquesta situació mitjançant mecanismes de gestió d'errors i reintent. Fa ús de la RateLimitError excepció per detectar quan s'envien massa sol·licituds en un període curt, provocant l'error. A més, els scripts utilitzen una estratègia de reintent per tornar a intentar automàticament la trucada a l'API després d'arribar al límit de velocitat.

Per implementar aquestes estratègies, el primer script defineix una funció anomenada crear_completar, que accepta una sol·licitud i el nombre de reintents permesos. Aquesta funció intenta fer una trucada a l'API de finalització d'OpenAI, generant una resposta basada en el model i l'indicador donats. Si es detecta un error de límit de velocitat, la funció imprimeix un missatge informatiu i es crida recursivament per tornar a intentar l'operació. Aquest enfocament és eficaç per evitar les terminacions abruptes dels scripts alhora que es gestionen els límits de velocitat de l'API de manera eficient.

Al segon script, s'implementa una estratègia similar de gestió d'errors, però inclou una lògica addicional per canviar de model si es supera el límit de velocitat. Això és especialment útil quan diferents models poden tenir límits de velocitat variables. L'script comença inicialitzant el client OpenAI mitjançant una funció personalitzada anomenada inicialitzar el client. Aquesta funció verifica la validesa de la clau de l'API, assegurant-se que l'script s'ha autenticat correctament abans de continuar amb més trucades. Si l'autenticació falla, retorna un missatge d'error clar a l'usuari, reduint la confusió al voltant de les configuracions incorrectes.

El segon script també introdueix una funció anomenada crear_xerrar, que prova una trucada a l'API utilitzant un model específic. Si a RateLimitError es genera, la funció imprimeix un missatge que indica que canviarà a un model alternatiu, com ara "davinci-002" a "davinci-003". Això demostra flexibilitat a l'hora de gestionar els límits de tarifes alhora que es continua donant resultats. A més, els scripts utilitzen variables d'entorn per gestionar de manera segura la clau de l'API mitjançant l' dotenv paquet, posant èmfasi en les pràctiques de codificació segura. Les variables d'entorn redueixen el risc d'exposar dades sensibles a la base de codi.

import os
from dotenv import load_dotenv
import openai
from openai.error import RateLimitError
# Load environment variables from a .env file
load_dotenv()
# Retrieve API key securely
api_key = os.getenv("OPENAI_API_KEY")
# Initialize OpenAI client
client = openai.OpenAI(api_key=api_key)
# Define a function to handle API calls with retry mechanism
def create_completion(prompt, retries=3):
    try:
        response = client.Completion.create(
            model="davinci-002",
            prompt=prompt,
            max_tokens=50
        )
        return response
    except RateLimitError as e:
        if retries > 0:
            print("Rate limit exceeded. Retrying...")
            return create_completion(prompt, retries - 1)
        else:
            print(f"Failed after multiple attempts: {str(e)}")
            return None
# Testing prompt
result = create_completion("Say this is a test")
if result:
    print(result)

import os
from dotenv import load_dotenv
import openai
from openai.error import RateLimitError, AuthenticationError
# Load environment variables
load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")
# Initialize OpenAI client with API key validation
def initialize_client(api_key):
    try:
        return openai.OpenAI(api_key=api_key)
    except AuthenticationError as auth_error:
        print("Invalid API key provided:", str(auth_error))
        return None
client = initialize_client(api_key)
# API call with fallback model if rate limit is reached
def create_chat(prompt, model="text-davinci-002"):
    try:
        response = client.Completion.create(
            model=model,
            prompt=prompt,
            max_tokens=60
        )
        return response
    except RateLimitError:
        print("Rate limit reached. Switching model...")
        return create_chat(prompt, model="text-davinci-003")
# Testing fallback mechanism
result = create_chat("Say this is another test")
if result:
    print(result)

Superació dels errors del límit de velocitat d'OpenAI als scripts de Python

Quan treballen amb l'API OpenAI, els usuaris sovint es troben amb un codi d'error 429, que indica que s'ha superat el nombre de sol·licituds d'API permeses. Això pot ser desconcertant, especialment per als principiants que han comprovat el seu saldo de crèdit i han confirmat que tenen prou fons. En aquests casos, és probable que el problema no es tracti del crèdit disponible, sinó dels límits de tarifes establerts per OpenAI. Aquests límits poden restringir el nombre de trucades a l'API que podeu fer durant un període de temps determinat. Comprendre i gestionar aquests límits de manera eficaç és crucial per construir una solució fiable.

Una manera de gestionar-ho és introduint un mecanisme de reintent, tal com es mostra als exemples de script anteriors. Tanmateix, un altre aspecte important a tenir en compte és entendre OpenAI polítiques de quotes en profunditat. OpenAI pot aplicar diferents límits de tarifa segons el model o el tipus de compte que s'utilitzi. Per exemple, els comptes de nivell gratuït poden enfrontar-se a límits més estrictes en comparació amb els nivells de pagament, que poden influir en la manera com dissenyeu les trucades de l'API. A més, els usuaris s'han d'assegurar que els seus permisos de clau de l'API estiguin configurats correctament, ja que una configuració incorrecta també pot provocar errors de quota.

A més de gestionar els reintents i triar models de reserva, és essencial optimitzar les trucades a l'API. Això inclou minimitzar les sol·licituds d'API innecessàries i centrar-se en les crítiques. Els desenvolupadors també poden fer un seguiment de les estadístiques d'ús de l'API des del tauler d'OpenAI per obtenir informació sobre els seus patrons de consum i ajustar els seus scripts en conseqüència. Amb la implementació d'aquestes estratègies, podeu reduir la probabilitat d'assolir els límits de velocitat i garantir una interacció més fluida amb l'API d'OpenAI.