Error Codes Reference

# Use valid commodity codes
valid_codes = ['WTI_USD', 'BRENT_CRUDE_USD', 'NATURAL_GAS_USD']
response = requests.get(
    f'https://api.oilpriceapi.com/v1/prices/latest?by_code={valid_codes[0]}'
)

import time
import requests

def make_request_with_retry(url, headers, max_retries=3):
    for attempt in range(max_retries):
        response = requests.get(url, headers=headers)

        if response.status_code == 429:
            reset_after = int(response.headers.get('X-RateLimit-Reset-After', 60))
            print(f"Rate limited. Waiting {reset_after} seconds...")
            time.sleep(reset_after)
            continue

        return response

    raise Exception("Max retries exceeded")

def handle_api_error(response):
    """Extract and handle API errors properly"""
    if response.status_code == 200:
        return response.json()

    try:
        error_data = response.json()
        error_code = error_data.get('error', {}).get('code')
        error_message = error_data.get('error', {}).get('message')
        error_details = error_data.get('error', {}).get('details', {})

        if error_code == 'RATE_LIMIT_EXCEEDED':
            # Wait and retry
            reset_after = error_details.get('reset_after', 60)
            time.sleep(reset_after)
            return None  # Signal retry

        elif error_code == 'INSUFFICIENT_PLAN':
            # Log and notify about plan upgrade
            upgrade_url = error_details.get('upgrade_url')
            logging.error(f"Plan upgrade needed: {upgrade_url}")

        elif error_code == 'INVALID_COMMODITY':
            # Use fallback commodity
            valid_codes = error_details.get('valid_codes', [])
            if valid_codes:
                return use_fallback_commodity(valid_codes[0])

    except json.JSONDecodeError:
        # Non-JSON error response
        logging.error(f"API error {response.status_code}: {response.text}")

    raise APIError(response.status_code, error_code, error_message)

def get_price_with_fallback(commodity_code):
    """Get price with fallback strategies"""

    # Try primary API
    try:
        return fetch_from_api(commodity_code)
    except APIError as e:
        if e.code == 'QUOTA_EXCEEDED':
            # Use cached data if quota exceeded
            return get_cached_price(commodity_code)

        elif e.code == 'COMMODITY_NOT_FOUND':
            # Try alternative commodity codes
            alternatives = {
                'WTI': 'WTI_USD',
                'BRENT': 'BRENT_CRUDE_USD',
                'GAS': 'NATURAL_GAS_USD'
            }
            if commodity_code in alternatives:
                return fetch_from_api(alternatives[commodity_code])

        elif e.code in ['INTERNAL_ERROR', 'SERVICE_UNAVAILABLE']:
            # Use last known good value
            return get_last_known_price(commodity_code)

        # Re-raise if no fallback available
        raise

# Test your error handling
def test_error_handling():
    test_cases = [
        # Missing API key
        {'headers': {}, 'expected_code': 'MISSING_API_KEY'},

        # Invalid API key
        {'headers': {'Authorization': 'Token invalid'},
         'expected_code': 'INVALID_API_KEY'},

        # Invalid commodity
        {'params': {'by_code': 'INVALID'},
         'expected_code': 'INVALID_COMMODITY'},

        # Invalid date range
        {'params': {'start': '2025-02-01', 'end': '2025-01-01'},
         'expected_code': 'INVALID_DATE_RANGE'}
    ]

    for test in test_cases:
        response = make_test_request(**test)
        assert response.get('error', {}).get('code') == test['expected_code']