Claude vs GPT-4o for Coding: In-Depth Comparison (June 2026)

Write a Python async HTTP client library with these features:
- Token-bucket rate limiting (configurable rate and burst)
- Retry with exponential backoff (configurable max retries and base delay)
- Circuit breaker pattern (closed → open after N failures → half-open for testing)
- Async/await throughout (httpx recommended)
- Type hints on all public methods
- Thread-safe (use time.monotonic(), not time.time())
- Include docstrings and a usage example

Output the complete implementation in a single file.

"""Async HTTP client with rate limiting, retry, and circuit breaker."""
import asyncio
import time
from dataclasses import dataclass, field
from enum import Enum
from typing import Optional

import httpx


class CircuitState(Enum):
    CLOSED = "closed"
    OPEN = "open"
    HALF_OPEN = "half_open"


@dataclass
class TokenBucket:
    """Thread-safe token bucket rate limiter using monotonic time."""
    rate: float  # tokens per second
    burst: int   # max burst capacity
    tokens: float = field(init=False)
    last_refill: float = field(default_factory=time.monotonic)

    def __post_init__(self) -> None:
        self.tokens = float(self.burst)

    async def acquire(self) -> None:
        """Acquire a token, waiting if necessary."""
        now = time.monotonic()
        elapsed = now - self.last_refill
        self.tokens = min(self.burst, self.tokens + elapsed * self.rate)
        self.last_refill = now

        if self.tokens < 1:
            wait = (1 - self.tokens) / self.rate
            await asyncio.sleep(wait)
            self.tokens = 0
        else:
            self.tokens -= 1


@dataclass
class CircuitBreaker:
    """Circuit breaker with closed → open → half-open lifecycle."""
    failure_threshold: int = 5
    recovery_timeout: float = 30.0
    failures: int = 0
    state: CircuitState = CircuitState.CLOSED
    last_failure: float = 0.0

    def record_failure(self) -> None:
        self.failures += 1
        self.last_failure = time.monotonic()
        if self.failures >= self.failure_threshold:
            self.state = CircuitState.OPEN

    def record_success(self) -> None:
        self.failures = 0
        self.state = CircuitState.CLOSED

    def allow_request(self) -> bool:
        if self.state == CircuitState.CLOSED:
            return True
        if self.state == CircuitState.OPEN:
            if time.monotonic() - self.last_failure >= self.recovery_timeout:
                self.state = CircuitState.HALF_OPEN
                return True
            return False
        return True  # HALF_OPEN — allow one probe request


class RateLimitedClient:
    """Async HTTP client combining rate limiting, retries, and circuit breaker."""

    def __init__(
        self,
        rate: float = 10.0,
        burst: int = 20,
        max_retries: int = 3,
        base_delay: float = 1.0,
        circuit_threshold: int = 5,
    ) -> None:
        self._bucket = TokenBucket(rate=rate, burst=burst)
        self._breaker = CircuitBreaker(failure_threshold=circuit_threshold)
        self._max_retries = max_retries
        self._base_delay = base_delay
        self._client: Optional[httpx.AsyncClient] = None

    async def _get_client(self) -> httpx.AsyncClient:
        if self._client is None:
            self._client = httpx.AsyncClient()
        return self._client

    async def request(self, method: str, url: str, **kwargs) -> httpx.Response:
        if not self._breaker.allow_request():
            raise CircuitBreakerOpenError("Circuit breaker is open.")

        for attempt in range(self._max_retries + 1):
            await self._bucket.acquire()
            client = await self._get_client()

            try:
                response = await client.request(method, url, **kwargs)
                response.raise_for_status()
                self._breaker.record_success()
                return response
            except httpx.HTTPStatusError as exc:
                if exc.response.status_code < 500 and attempt == self._max_retries:
                    raise
                delay = self._base_delay * (2 ** attempt)
                await asyncio.sleep(delay)
            except (httpx.RequestError, httpx.TimeoutException):
                self._breaker.record_failure()
                if attempt == self._max_retries:
                    raise
                delay = self._base_delay * (2 ** attempt)
                await asyncio.sleep(delay)

        raise RuntimeError("Unreachable — max retries exceeded.")


class CircuitBreakerOpenError(Exception):
    """Raised when a request is attempted while the circuit breaker is open."""

import asyncio
import time
from enum import Enum

import httpx


class CircuitState(Enum):
    CLOSED = "closed"
    OPEN = "open"
    HALF_OPEN = "half_open"


class RateLimiter:
    def __init__(self, rate, capacity):
        self.rate = rate
        self.capacity = capacity
        self.tokens = capacity
        self.last_check = time.time()

    def _add_tokens(self):
        now = time.time()
        elapsed = now - self.last_check
        self.tokens = min(self.capacity, self.tokens + elapsed * self.rate)
        self.last_check = now

    async def wait_if_needed(self):
        self._add_tokens()
        if self.tokens >= 1:
            self.tokens -= 1
            return
        wait = (1 - self.tokens) / self.rate
        await asyncio.sleep(wait)
        self.tokens = 0


class CircuitBreaker:
    def __init__(self, threshold=5, timeout=30):
        self.threshold = threshold
        self.timeout = timeout
        self.failures = 0
        self.state = CircuitState.CLOSED
        self.last_failure = 0

    def call(self, func, *args, **kwargs):
        if self.state == CircuitState.OPEN:
            if time.time() - self.last_failure > self.timeout:
                self.state = CircuitState.HALF_OPEN
            else:
                raise Exception("Circuit breaker open")
        try:
            result = func(*args, **kwargs)
            self.failures = 0
            self.state = CircuitState.CLOSED
            return result
        except Exception:
            self.failures += 1
            self.last_failure = time.time()
            if self.failures >= self.threshold:
                self.state = CircuitState.OPEN
            raise


class RateLimitedClient:
    def __init__(self, rate=10, burst=20, retries=3, delay=1):
        self.limiter = RateLimiter(rate, burst)
        self.breaker = CircuitBreaker()
        self.retries = retries
        self.delay = delay
        self.client = httpx.AsyncClient()