速率限制(Rate limits)

import tenacity
 
@tenacity.retry(wait=tenacity.wait_random_exponential(multiplier=1, max=60))
def make_request():
    # Make your request here

import openai
from tenacity import (
    retry,
    stop_after_attempt,
    wait_random_exponential,
) # for exponential backoff
 
@retry(wait=wait_random_exponential(min=1, max=60), stop=stop_after_attempt(6))
def completion_with_backoff(**kwargs):
 return openai.Completion.create(**kwargs)
 
completion_with_backoff(model="text-davinci-003", prompt="Once upon a time,")

import backoff 
import openai 
@backoff.on_exception(backoff.expo, openai.error.RateLimitError)
def completions_with_backoff(**kwargs):
 return openai.Completion.create(**kwargs)
 
completions_with_backoff(model="text-davinci-003", prompt="Once upon a time,")

import time 
def make_request():
    # Make your request here
    response = ... # The response from your request
    while "retry-after" in response.headers:
      delay = int(reponse.headers["retry-after"])
      time.sleep(delay)
      response = ... # Retry the request

# imports
import random
import time
 
import openai
 
# define a retry decorator
def retry_with_exponential_backoff(
 func,
 initial_delay: float = 1,
 exponential_base: float = 2,
 jitter: bool = True,
 max_retries: int = 10,
 errors: tuple = (openai.error.RateLimitError,),
):
 """Retry a function with exponential backoff."""
 
 def wrapper(*args, **kwargs):
 # Initialize variables
 num_retries = 0
        delay = initial_delay
 
 # Loop until a successful response or max_retries is hit or an exception is raised
 while True:
 try:
 return func(*args, **kwargs)
 
 # Retry on specific errors
 except errors as e:
 # Increment retries
 num_retries += 1
 
 # Check if max retries has been reached
 if num_retries > max_retries:
 raise Exception(
 f"Maximum number of retries ({max_retries}) exceeded."
                    )
 
 # Increment the delay
 delay *= exponential_base * (1 + jitter * random.random())
 
 # Sleep for the delay
                time.sleep(delay)
 
 # Raise exceptions for any errors not specified
 except Exception as e:
 raise e
 
 return wrapper
 
@retry_with_exponential_backoff
def completions_with_backoff(**kwargs):
 return openai.Completion.create(**kwargs)

import openai
 
num_stories = 10
prompt = "Once upon a time,"
 
# 串行示例，每个请求完成一个故事
for _ in range(num_stories):
    response = openai.Completion.create(
        model="curie",
        prompt=prompt,
        max_tokens=20,
    )
    # print story
    print(prompt + response.choices[0].text)

import openai
 
num_stories = 10
prompt = "Once upon a time,"
 
# create a list of prompts and send a single request for all stories
prompts = [prompt]*num_stories
responses = openai.Completion.create(
   engine="curie",
   prompt=prompts,
   max_tokens=20,
   n=1,
   stop=None,
   temperature=0.5,
   frequency_penalty=0,
   presence_penalty=0,
)
 
# print each story from the response
for response in responses.choices:
   print(prompt + response.text)

import openai  # for making OpenAI API requests
 
 
num_stories = 10
prompts = ["Once upon a time,"] * num_stories
 
# batched example, with 10 story completions per request
response = openai.Completion.create(
    model="curie",
    prompt=prompts,
    max_tokens=20,
)
 
# match completions to prompts by index
stories = [""] * len(prompts)
for choice in response.choices:
    stories[choice.index] = prompts[choice.index] + choice.text
 
# print stories
for story in stories:
    print(story)