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 { OpenAI } from 'openai';

const client = new OpenAI({
    baseURL: 'https://api.electronhub.ai/v1',
    apiKey: 'ek-your-api-key'
});

async function makeRequestWithRetry(maxRetries = 3) {
    for (let attempt = 0; attempt < maxRetries; attempt++) {
        try {
            const response = await client.chat.completions.create({
                model: 'gpt-4o',
                messages: [{ role: 'user', content: 'Hello!' }]
            });
            return response;
            
        } catch (error) {
            if (error.status === 429 && attempt < maxRetries - 1) {
                // Exponential backoff with jitter
                const waitTime = (2 ** attempt + Math.random()) * 1000;
                console.log(`Rate limited. Waiting ${waitTime/1000:.2f} seconds...`);
                await new Promise(resolve => setTimeout(resolve, waitTime));
            } else {
                throw error;
            }
        }
    }
}

// Usage
const response = await makeRequestWithRetry();

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)

class RateLimitedClient {
    constructor(client, rpmLimit) {
        this.client = client;
        this.rpmLimit = rpmLimit;
        this.requestTimes = [];
    }
    
    async makeRequest(requestFunc) {
        const now = Date.now();
        
        // Remove requests older than 60 seconds
        const cutoff = now - 60000;
        this.requestTimes = this.requestTimes.filter(t => t > cutoff);
        
        // Check if we need to wait
        if (this.requestTimes.length >= this.rpmLimit) {
            const waitTime = 60000 - (now - this.requestTimes[0]);
            if (waitTime > 0) {
                await new Promise(resolve => setTimeout(resolve, waitTime));
            }
        }
        
        // Make the request
        this.requestTimes.push(Date.now());
        return await requestFunc();
    }
}

// Usage
const rateLimitedClient = new RateLimitedClient(client, 20);

const response = await rateLimitedClient.makeRequest(() =>
    client.chat.completions.create({
        model: 'gpt-4o',
        messages: [{ role: 'user', content: 'Hello!' }]
    })
);

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!")

function checkRateLimitStatus(response) {
    const headers = response.response.headers;
    const limit = parseInt(headers['x-ratelimit-limit'] || '0');
    const remaining = parseInt(headers['x-ratelimit-remaining'] || '0');
    const resetTime = parseInt(headers['x-ratelimit-reset'] || '0');
    
    console.log(`Rate Limit: ${limit}`);
    console.log(`Remaining: ${remaining}`);
    console.log(`Resets at: ${resetTime}`);
    
    if (remaining < 5) {
        console.log('⚠️  Warning: Approaching rate limit!');
    }
}