Rate Limits

import time
import random
from openai import OpenAI, RateLimitError

client = OpenAI(
    base_url="https://api.electronhub.ai/v1",
    api_key="ek-your-api-key"
)

def make_request_with_retry(max_retries=3):
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="gpt-4o",
                messages=[{"role": "user", "content": "Hello!"}]
            )
            return response
            
        except RateLimitError:
            if attempt < max_retries - 1:
                # Exponential backoff with jitter
                wait_time = (2 ** attempt) + random.uniform(0, 1)
                print(f"Rate limited. Waiting {wait_time:.2f} seconds...")
                time.sleep(wait_time)
            else:
                raise
    
    return None

# Usage
response = make_request_with_retry()

import asyncio
import time
from typing import List, Callable

class RateLimitedClient:
    def __init__(self, client, rpm_limit: int):
        self.client = client
        self.rpm_limit = rpm_limit
        self.request_times: List[float] = []
        self.lock = asyncio.Lock()
    
    async def make_request(self, request_func: Callable):
        async with self.lock:
            now = time.time()
            
            # Remove requests older than 60 seconds
            cutoff = now - 60
            self.request_times = [t for t in self.request_times if t > cutoff]
            
            # Check if we need to wait
            if len(self.request_times) >= self.rpm_limit:
                wait_time = 60 - (now - self.request_times[0])
                if wait_time > 0:
                    await asyncio.sleep(wait_time)
                    now = time.time()
            
            # Make the request
            self.request_times.append(now)
            return await request_func()

# Usage
rate_limited_client = RateLimitedClient(client, rpm_limit=20)

async def my_request():
    return client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": "Hello!"}]
    )

response = await rate_limited_client.make_request(my_request)

def check_rate_limit_status(response):
    headers = response.response.headers
    limit = int(headers.get('x-ratelimit-limit', 0))
    remaining = int(headers.get('x-ratelimit-remaining', 0))
    reset_time = int(headers.get('x-ratelimit-reset', 0))
    
    print(f"Rate Limit: {limit}")
    print(f"Remaining: {remaining}")
    print(f"Resets at: {reset_time}")
    
    if remaining < 5:
        print("⚠️  Warning: Approaching rate limit!")