Error Handling

{
  "error": {
    "code": "ERROR_CODE",
    "message": "Human-readable error message",
    "details": {
      "field": "additional_context",
      "retry_after": 60
    }
  }
}

import time
import random
import requests

def make_request_with_retry(url, headers, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.get(url, headers=headers)
            
            if response.status_code == 200:
                return response.json()
            
            elif response.status_code == 429:
                # Rate limited - respect retry_after
                error_data = response.json()
                retry_after = error_data.get('error', {}).get('details', {}).get('retry_after', 60)
                print(f"Rate limited. Waiting {retry_after} seconds...")
                time.sleep(retry_after)
                continue
            
            elif response.status_code in [500, 502, 503, 504]:
                # Server error - exponential backoff
                wait_time = (2 ** attempt) + random.uniform(0, 1)
                print(f"Server error. Retrying in {wait_time:.2f} seconds...")
                time.sleep(wait_time)
                continue
            
            else:
                # Client error - don't retry
                print(f"Client error: {response.status_code}")
                response.raise_for_status()
                
        except requests.exceptions.RequestException as e:
            if attempt == max_retries - 1:
                raise e
            
            wait_time = (2 ** attempt) + random.uniform(0, 1)
            print(f"Request failed. Retrying in {wait_time:.2f} seconds...")
            time.sleep(wait_time)
    
    raise Exception(f"Max retries ({max_retries}) exceeded")

# Usage
try:
    data = make_request_with_retry(
        "https://api.u1.archetypeai.app/v0.5/lens/info",
        {"Authorization": "Bearer YOUR_API_KEY"}
    )
    print(data)
except Exception as e:
    print(f"Request failed after retries: {e}")

import time
from enum import Enum

class CircuitState(Enum):
    CLOSED = "closed"      # Normal operation
    OPEN = "open"          # Failing, reject requests
    HALF_OPEN = "half_open"  # Testing if service recovered

class CircuitBreaker:
    def __init__(self, failure_threshold=5, recovery_timeout=60):
        self.failure_threshold = failure_threshold
        self.recovery_timeout = recovery_timeout
        self.failure_count = 0
        self.last_failure_time = None
        self.state = CircuitState.CLOSED
    
    def call(self, func, *args, **kwargs):
        if self.state == CircuitState.OPEN:
            if self._should_attempt_reset():
                self.state = CircuitState.HALF_OPEN
            else:
                raise Exception("Circuit breaker is OPEN")
        
        try:
            result = func(*args, **kwargs)
            self._on_success()
            return result
        except Exception as e:
            self._on_failure()
            raise e
    
    def _should_attempt_reset(self):
        return (time.time() - self.last_failure_time) >= self.recovery_timeout
    
    def _on_success(self):
        self.failure_count = 0
        self.state = CircuitState.CLOSED
    
    def _on_failure(self):
        self.failure_count += 1
        self.last_failure_time = time.time()
        
        if self.failure_count >= self.failure_threshold:
            self.state = CircuitState.OPEN

# Usage
circuit_breaker = CircuitBreaker()

def api_call():
    response = requests.get(
        "https://api.u1.archetypeai.app/v0.5/lens/info",
        headers={"Authorization": "Bearer YOUR_API_KEY"}
    )
    response.raise_for_status()
    return response.json()

try:
    data = circuit_breaker.call(api_call)
    print(data)
except Exception as e:
    print(f"Circuit breaker prevented call: {e}")

import logging
import json

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

def log_api_error(response, request_details):
    """Log API errors for monitoring and debugging"""
    try:
        error_data = response.json()
        logger.error(
            "API Error",
            extra={
                "status_code": response.status_code,
                "error_code": error_data.get('error', {}).get('code'),
                "error_message": error_data.get('error', {}).get('message'),
                "request_url": request_details.get('url'),
                "request_method": request_details.get('method'),
                "response_body": error_data
            }
        )
    except Exception:
        logger.error(
            "API Error (unparseable response)",
            extra={
                "status_code": response.status_code,
                "response_text": response.text,
                "request_url": request_details.get('url'),
                "request_method": request_details.get('method')
            }
        )

# Usage in your API calls
response = requests.get(url, headers=headers)
if not response.ok:
    log_api_error(response, {"url": url, "method": "GET"})
    response.raise_for_status()