Error Handling¶

try:
    response = requests.post(
        f"{API_URL}/jobs/{job_id}/llm-call",
        headers=headers,
        json={"messages": messages}
    )
    response.raise_for_status()
except requests.exceptions.HTTPError as e:
    if e.response.status_code == 400:
        error_detail = e.response.json()
        print(f"Bad request: {error_detail['detail']}")
        # Fix the request format
        # Log the issue for debugging

try:
    response = requests.post(
        f"{API_URL}/jobs/create",
        headers={"Authorization": f"Bearer {VIRTUAL_KEY}"},
        json={"team_id": "acme-corp", "job_type": "test"}
    )
    response.raise_for_status()
except requests.exceptions.HTTPError as e:
    if e.response.status_code == 401:
        print("Authentication failed. Check your virtual key.")
        # Attempt to refresh the key
        # Notify admin
        # Fall back to cached data if possible

try:
    response = requests.post(
        f"{API_URL}/jobs/{job_id}/llm-call",
        headers=headers,
        json={"messages": messages}
    )
    response.raise_for_status()
except requests.exceptions.HTTPError as e:
    if e.response.status_code == 403:
        error_detail = e.response.json()
        print(f"Access denied: {error_detail['detail']}")

        # Check team status
        team_response = requests.get(
            f"{API_URL}/teams/{team_id}",
            headers=headers
        )
        team_info = team_response.json()

        if team_info['status'] == 'suspended':
            print("Team is suspended. Contact administrator.")
        elif team_info['credits_remaining'] <= 0:
            print("Out of credits. Please add credits to continue.")
        else:
            print("Model access denied. Check access groups.")

try:
    response = requests.post(
        f"{API_URL}/jobs/{job_id}/llm-call",
        headers=headers,
        json={"messages": messages}
    )
    response.raise_for_status()
except requests.exceptions.HTTPError as e:
    if e.response.status_code == 404:
        print(f"Job {job_id} not found")
        # Create a new job
        job = create_new_job()
        # Retry with the new job_id

try:
    response = requests.post(
        f"{API_URL}/jobs/create",
        headers=headers,
        json={"team_id": "acme-corp"}  # Missing job_type
    )
    response.raise_for_status()
except requests.exceptions.HTTPError as e:
    if e.response.status_code == 422:
        errors = e.response.json()['detail']
        for error in errors:
            field = '.'.join(str(x) for x in error['loc'])
            print(f"Validation error on {field}: {error['msg']}")

import time

def make_request_with_retry(url, headers, data, max_retries=3):
    """Make request with exponential backoff for rate limits"""
    for attempt in range(max_retries):
        try:
            response = requests.post(url, headers=headers, json=data)
            response.raise_for_status()
            return response.json()

        except requests.exceptions.HTTPError as e:
            if e.response.status_code == 429:
                if attempt < max_retries - 1:
                    # Exponential backoff: 1s, 2s, 4s
                    wait_time = 2 ** attempt
                    print(f"Rate limited. Waiting {wait_time}s...")
                    time.sleep(wait_time)
                else:
                    print("Rate limit exceeded after all retries")
                    raise
            else:
                raise

try:
    response = requests.post(
        f"{API_URL}/jobs/{job_id}/llm-call",
        headers=headers,
        json={"messages": messages}
    )
    response.raise_for_status()
except requests.exceptions.HTTPError as e:
    if e.response.status_code == 500:
        print("Server error. Retrying...")
        # Retry with exponential backoff
        time.sleep(5)
        # Retry the request

try:
    response = requests.post(
        f"{API_URL}/jobs/{job_id}/llm-call",
        headers=headers,
        json={"messages": messages}
    )
    response.raise_for_status()
except requests.exceptions.HTTPError as e:
    if e.response.status_code == 503:
        print("Service unavailable. Please try again later.")
        # Implement retry with longer delays

import requests
from requests.exceptions import ConnectionError, Timeout

try:
    response = requests.post(
        f"{API_URL}/jobs/create",
        headers=headers,
        json={"team_id": "acme-corp", "job_type": "test"},
        timeout=30  # 30 second timeout
    )
except ConnectionError as e:
    print(f"Connection error: {e}")
    # Check network connectivity
    # Retry with different endpoint if available
except Timeout as e:
    print(f"Request timed out: {e}")
    # Retry with longer timeout

try:
    response = requests.post(
        f"{API_URL}/jobs/{job_id}/llm-call",
        headers=headers,
        json={"messages": messages},
        timeout=30
    )
except Timeout:
    print("Request timed out after 30 seconds")
    # Increase timeout
    # Or switch to streaming for long responses

import asyncio

async def robust_streaming():
    async with SaaSLLMClient(base_url, team_id, virtual_key) as client:
        job_id = await client.create_job("chat")

        try:
            accumulated = ""
            chunk_count = 0

            async for chunk in client.chat_stream(
                job_id=job_id,
                messages=[{"role": "user", "content": "Tell me a story"}]
            ):
                chunk_count += 1
                if chunk.choices:
                    content = chunk.choices[0].delta.get("content", "")
                    accumulated += content
                    print(content, end="", flush=True)

            print(f"\n\nStream completed successfully ({chunk_count} chunks)")
            await client.complete_job(job_id, "completed")

        except asyncio.TimeoutError:
            print("\n\nStream timed out")
            await client.complete_job(job_id, "failed")

        except Exception as e:
            print(f"\n\nStream error: {e}")
            await client.complete_job(job_id, "failed")

            # Log the partial response
            if accumulated:
                print(f"Partial response received: {accumulated[:100]}...")

import asyncio

async def streaming_with_timeout():
    async with SaaSLLMClient(base_url, team_id, virtual_key) as client:
        job_id = await client.create_job("chat")

        try:
            # Set overall timeout for the stream
            async with asyncio.timeout(60):  # 60 seconds
                async for chunk in client.chat_stream(
                    job_id=job_id,
                    messages=[{"role": "user", "content": "Write a long essay"}]
                ):
                    # Process chunks
                    pass

        except asyncio.TimeoutError:
            print("Stream exceeded 60 second timeout")
            await client.complete_job(job_id, "failed")

import requests
import time
from typing import Optional, Dict, Any

class APIError(Exception):
    """Base exception for API errors"""
    pass

class AuthenticationError(APIError):
    """Authentication failed"""
    pass

class InsufficientCreditsError(APIError):
    """Team out of credits"""
    pass

class RateLimitError(APIError):
    """Rate limit exceeded"""
    pass

class ServerError(APIError):
    """Server-side error"""
    pass

def make_api_request(
    url: str,
    headers: Dict[str, str],
    data: Dict[str, Any],
    max_retries: int = 3,
    timeout: int = 30
) -> Dict[str, Any]:
    """
    Make API request with comprehensive error handling and retries.

    Args:
        url: API endpoint URL
        headers: Request headers
        data: Request body
        max_retries: Maximum number of retries
        timeout: Request timeout in seconds

    Returns:
        API response data

    Raises:
        AuthenticationError: If authentication fails
        InsufficientCreditsError: If team is out of credits
        RateLimitError: If rate limit exceeded after retries
        ServerError: If server error after retries
        APIError: For other API errors
    """
    for attempt in range(max_retries):
        try:
            response = requests.post(
                url,
                headers=headers,
                json=data,
                timeout=timeout
            )
            response.raise_for_status()
            return response.json()

        except requests.exceptions.Timeout:
            print(f"Request timed out (attempt {attempt + 1}/{max_retries})")
            if attempt == max_retries - 1:
                raise APIError("Request timed out after all retries")
            time.sleep(2 ** attempt)

        except requests.exceptions.ConnectionError as e:
            print(f"Connection error (attempt {attempt + 1}/{max_retries}): {e}")
            if attempt == max_retries - 1:
                raise APIError(f"Connection failed after all retries: {e}")
            time.sleep(2 ** attempt)

        except requests.exceptions.HTTPError as e:
            status_code = e.response.status_code
            detail = e.response.json().get("detail", "Unknown error")

            # 401: Authentication error (don't retry)
            if status_code == 401:
                raise AuthenticationError(f"Authentication failed: {detail}")

            # 403: Forbidden (don't retry)
            elif status_code == 403:
                if "credit" in detail.lower():
                    raise InsufficientCreditsError(f"Insufficient credits: {detail}")
                else:
                    raise APIError(f"Access denied: {detail}")

            # 404: Not found (don't retry)
            elif status_code == 404:
                raise APIError(f"Resource not found: {detail}")

            # 422: Validation error (don't retry)
            elif status_code == 422:
                raise APIError(f"Validation error: {detail}")

            # 429: Rate limit (retry with backoff)
            elif status_code == 429:
                if attempt < max_retries - 1:
                    wait_time = 2 ** attempt
                    print(f"Rate limited. Waiting {wait_time}s (attempt {attempt + 1}/{max_retries})")
                    time.sleep(wait_time)
                else:
                    raise RateLimitError(f"Rate limit exceeded after all retries: {detail}")

            # 500/503: Server errors (retry with backoff)
            elif status_code in [500, 503]:
                if attempt < max_retries - 1:
                    wait_time = 2 ** attempt
                    print(f"Server error. Retrying in {wait_time}s (attempt {attempt + 1}/{max_retries})")
                    time.sleep(wait_time)
                else:
                    raise ServerError(f"Server error after all retries: {detail}")

            # Other errors
            else:
                raise APIError(f"HTTP {status_code}: {detail}")

    raise APIError("Request failed after all retries")

# Usage
try:
    result = make_api_request(
        url=f"{API_URL}/jobs/create",
        headers={"Authorization": f"Bearer {VIRTUAL_KEY}"},
        data={"team_id": "acme-corp", "job_type": "test"}
    )
    print(f"Job created: {result['job_id']}")

except AuthenticationError as e:
    print(f"Auth error: {e}")
    # Refresh virtual key or notify admin

except InsufficientCreditsError as e:
    print(f"Credits error: {e}")
    # Notify user to add credits

except RateLimitError as e:
    print(f"Rate limit error: {e}")
    # Queue request for later

except ServerError as e:
    print(f"Server error: {e}")
    # Log error and notify ops team

except APIError as e:
    print(f"API error: {e}")
    # Generic error handling

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 make_logged_request(url, headers, data):
    """Make request with detailed logging"""
    request_id = str(uuid.uuid4())

    logger.info(f"Request {request_id}: POST {url}")

    try:
        response = requests.post(url, headers=headers, json=data, timeout=30)
        response.raise_for_status()

        logger.info(f"Request {request_id}: Success (status={response.status_code})")
        return response.json()

    except requests.exceptions.HTTPError as e:
        logger.error(
            f"Request {request_id}: HTTP error",
            extra={
                "status_code": e.response.status_code,
                "detail": e.response.json().get("detail", "Unknown"),
                "url": url
            }
        )
        raise

    except Exception as e:
        logger.error(
            f"Request {request_id}: Failed",
            extra={"error": str(e), "url": url}
        )
        raise

import time
from collections import defaultdict

class APIMetrics:
    """Track API metrics"""

    def __init__(self):
        self.requests = defaultdict(int)
        self.errors = defaultdict(int)
        self.latencies = []

    def record_request(self, endpoint: str, latency_ms: float, success: bool):
        """Record a request"""
        self.requests[endpoint] += 1
        self.latencies.append(latency_ms)

        if not success:
            self.errors[endpoint] += 1

    def get_stats(self):
        """Get aggregated stats"""
        total_requests = sum(self.requests.values())
        total_errors = sum(self.errors.values())
        avg_latency = sum(self.latencies) / len(self.latencies) if self.latencies else 0

        return {
            "total_requests": total_requests,
            "total_errors": total_errors,
            "error_rate": total_errors / total_requests if total_requests > 0 else 0,
            "avg_latency_ms": avg_latency,
            "p95_latency_ms": sorted(self.latencies)[int(len(self.latencies) * 0.95)] if self.latencies else 0
        }

# Usage
metrics = APIMetrics()

def make_tracked_request(url, headers, data):
    """Make request with metrics tracking"""
    start_time = time.time()
    success = False

    try:
        response = requests.post(url, headers=headers, json=data, timeout=30)
        response.raise_for_status()
        success = True
        return response.json()

    finally:
        latency_ms = (time.time() - start_time) * 1000
        metrics.record_request(url, latency_ms, success)

# Later, check metrics
stats = metrics.get_stats()
print(f"Total requests: {stats['total_requests']}")
print(f"Error rate: {stats['error_rate']:.2%}")
print(f"Avg latency: {stats['avg_latency_ms']:.0f}ms")

import time
import random

def exponential_backoff_with_jitter(attempt: int, base_delay: float = 1.0, max_delay: float = 32.0) -> float:
    """
    Calculate exponential backoff with jitter.

    Args:
        attempt: Current retry attempt (0-indexed)
        base_delay: Base delay in seconds
        max_delay: Maximum delay in seconds

    Returns:
        Delay in seconds with random jitter
    """
    # Exponential: base_delay * 2^attempt
    delay = min(base_delay * (2 ** attempt), max_delay)

    # Add jitter (±25% random variation)
    jitter = delay * 0.25 * (2 * random.random() - 1)

    return delay + jitter

def make_request_with_smart_retry(
    url: str,
    headers: dict,
    data: dict,
    max_retries: int = 3,
    timeout: int = 30
) -> dict:
    """
    Make API request with intelligent retry logic.

    Retries:
    - 429 (Rate Limit): Up to max_retries with exponential backoff
    - 500/503 (Server errors): Up to max_retries with exponential backoff
    - Timeouts/Connection errors: Up to max_retries with exponential backoff

    Does NOT retry:
    - 400, 401, 403, 404, 422: Client errors that won't be fixed by retrying
    """
    for attempt in range(max_retries):
        try:
            response = requests.post(url, headers=headers, json=data, timeout=timeout)
            response.raise_for_status()
            return response.json()

        except requests.exceptions.Timeout:
            if attempt < max_retries - 1:
                delay = exponential_backoff_with_jitter(attempt)
                print(f"Timeout. Retrying in {delay:.1f}s (attempt {attempt + 1}/{max_retries})")
                time.sleep(delay)
            else:
                raise APIError("Request timed out after all retries")

        except requests.exceptions.ConnectionError:
            if attempt < max_retries - 1:
                delay = exponential_backoff_with_jitter(attempt)
                print(f"Connection error. Retrying in {delay:.1f}s (attempt {attempt + 1}/{max_retries})")
                time.sleep(delay)
            else:
                raise APIError("Connection failed after all retries")

        except requests.exceptions.HTTPError as e:
            status_code = e.response.status_code
            detail = e.response.json().get("detail", "Unknown error")

            # Don't retry client errors (4xx except 429)
            if 400 <= status_code < 500 and status_code != 429:
                if status_code == 401:
                    raise AuthenticationError(f"Authentication failed: {detail}")
                elif status_code == 403:
                    raise APIError(f"Forbidden: {detail}")
                elif status_code == 404:
                    raise APIError(f"Not found: {detail}")
                elif status_code == 422:
                    raise APIError(f"Validation error: {detail}")
                else:
                    raise APIError(f"Client error {status_code}: {detail}")

            # Retry 429 and 5xx errors
            if attempt < max_retries - 1:
                delay = exponential_backoff_with_jitter(attempt)
                print(f"HTTP {status_code}. Retrying in {delay:.1f}s (attempt {attempt + 1}/{max_retries})")
                time.sleep(delay)
            else:
                if status_code == 429:
                    raise RateLimitError(f"Rate limit exceeded: {detail}")
                else:
                    raise ServerError(f"Server error {status_code}: {detail}")

    raise APIError("Request failed after all retries")

ENDPOINT_TIMEOUTS = {
    "/api/jobs/create": 10,
    "/api/jobs/": 10,  # GET job
    "/api/jobs/.*llm-call": 60,
    "/api/jobs/.*complete": 30,
    "/api/jobs/create-and-call": 60,
}

def get_timeout_for_endpoint(url: str) -> int:
    """Get recommended timeout for endpoint"""
    for pattern, timeout in ENDPOINT_TIMEOUTS.items():
        if pattern in url:
            return timeout
    return 30  # Default

# Usage
timeout = get_timeout_for_endpoint(url)
response = requests.post(url, json=data, timeout=timeout)

# ✅ Good - With appropriate timeout
response = requests.post(url, json=data, timeout=30)

# ✅ Better - With endpoint-specific timeout
timeout = get_timeout_for_endpoint(url)
response = requests.post(url, json=data, timeout=timeout)

# ❌ Bad - Can hang forever
response = requests.post(url, json=data)

# ✅ Good - Exponential backoff with jitter
for attempt in range(3):
    try:
        response = requests.post(url, json=data, timeout=30)
        response.raise_for_status()
        break
    except requests.exceptions.HTTPError as e:
        if e.response.status_code in [429, 500, 503] and attempt < 2:
            delay = (2 ** attempt) + random.uniform(0, 0.5)
            time.sleep(delay)
        else:
            raise

# ❌ Bad - Fixed delay, retries everything
for attempt in range(3):
    try:
        response = requests.post(url, json=data, timeout=30)
        response.raise_for_status()
        break
    except:
        time.sleep(1)  # Always 1 second, no distinction between errors

# ✅ Good - Handle specific errors differently
try:
    response = make_request()
except AuthenticationError:
    # Refresh key
    pass
except InsufficientCreditsError:
    # Notify user
    pass
except RateLimitError:
    # Queue for later
    pass

# ❌ Bad - Catch-all error handling
try:
    response = make_request()
except Exception:
    # What went wrong?
    pass

try:
    response = make_request()
except Exception as e:
    logger.error(
        "API request failed",
        extra={
            "error": str(e),
            "error_type": type(e).__name__,
            "team_id": team_id,
            "job_id": job_id,
            "url": url,
            "attempt": attempt,
            "status_code": getattr(e.response, 'status_code', None)
        }
    )

try:
    # Make LLM call
    response = llm_call(job_id, messages)
    # Complete successfully
    complete_job(job_id, "completed")
except Exception as e:
    # Mark job as failed (important for credit tracking!)
    complete_job(job_id, "failed", error_message=str(e))
    raise

from datetime import datetime, timedelta

class CircuitBreaker:
    """Simple circuit breaker implementation"""

    def __init__(self, failure_threshold: int = 5, timeout: int = 60):
        self.failure_threshold = failure_threshold
        self.timeout = timeout
        self.failures = 0
        self.last_failure_time = None
        self.state = "closed"  # closed, open, half_open

    def call(self, func, *args, **kwargs):
        """Call function with circuit breaker"""

        # If circuit is open, check if timeout expired
        if self.state == "open":
            if datetime.now() - self.last_failure_time > timedelta(seconds=self.timeout):
                self.state = "half_open"
                self.failures = 0
            else:
                raise APIError("Circuit breaker is open")

        try:
            result = func(*args, **kwargs)

            # Success - reset failures
            if self.state == "half_open":
                self.state = "closed"
            self.failures = 0

            return result

        except (ServerError, RateLimitError) as e:
            # Track failures
            self.failures += 1
            self.last_failure_time = datetime.now()

            # Open circuit if threshold exceeded
            if self.failures >= self.failure_threshold:
                self.state = "open"

            raise

# Usage
circuit_breaker = CircuitBreaker(failure_threshold=5, timeout=60)

try:
    result = circuit_breaker.call(
        make_api_request,
        url=url,
        headers=headers,
        data=data
    )
except APIError as e:
    print(f"Request failed: {e}")