Chapter 7: Using API Keys Safely

# Weather API credentials
OPENWEATHER_API_KEY=a7d4f2c8e1b9f3d6a8c4e7f2b5d8c3a9

# Database connection (for future chapters)
DATABASE_URL=postgresql://localhost/weather_db

# Email service credentials (for future features)
EMAIL_API_KEY=e9f2b5d8c3a9a7d4f2c8e1b9f3d6a8c4

# Debug mode for development
DEBUG=True

$ pip install python-dotenv

import os
import requests
from dotenv import load_dotenv

# Load environment variables from .env file
# This must happen before calling os.getenv()
load_dotenv()

def get_weather(city):
    """
    Fetch weather data using credentials from .env file.
    
    The .env file should contain:
    OPENWEATHER_API_KEY=your_actual_key_here
    """
    
    # Now os.getenv() will find variables from .env
    api_key = os.getenv("OPENWEATHER_API_KEY")
    
    if api_key is None:
        print("Error: OPENWEATHER_API_KEY not found in .env file")
        print("Create a .env file with: OPENWEATHER_API_KEY=your_key_here")
        return None
    
    # Rest of your code works exactly the same
    url = "https://api.openweathermap.org/data/2.5/weather"
    params = {
        "q": city,
        "appid": api_key,
        "units": "metric"
    }
    
    try:
        response = requests.get(url, params=params, timeout=10)
        
        if response.status_code == 401:
            return "Authentication failed - check your API key"
        
        elif response.status_code == 429:
            return "Rate limit exceeded - wait before retrying"
        
        elif not response.ok:
            return f"Request failed: {response.status_code}"
        
        data = response.json()
        main = data.get("main", {})
        weather = data.get("weather", [{}])[0]
        
        temp = main.get("temp", "Unknown")
        description = weather.get("description", "Unknown")
        
        return f"{city}: {temp}°C, {description}"
    
    except requests.exceptions.Timeout:
        return "Request timed out"
    except requests.exceptions.RequestException as e:
        return f"Request failed: {e}"


if __name__ == "__main__":
    print(get_weather("Dublin"))
    print(get_weather("London"))
    print(get_weather("Paris"))

import os
import sys
from dotenv import load_dotenv

def validate_environment():
    """
    Validate all required environment variables at startup.
    Exit with clear error message if anything is missing or invalid.
    
    This runs before any API calls, preventing cryptic runtime errors.
    """
    load_dotenv()
    
    # Define all required variables
    required_vars = {
        "OPENWEATHER_API_KEY": {
            "description": "OpenWeatherMap API key",
            "min_length": 30,  # OpenWeatherMap keys are ~32 chars
            "where_to_get": "https://openweathermap.org/api"
        }
    }
    
    missing = []
    invalid = []
    
    # Check each required variable
    for var_name, config in required_vars.items():
        value = os.getenv(var_name)
        
        if value is None:
            missing.append((var_name, config))
        elif len(value) < config["min_length"]:
            invalid.append((var_name, config, f"too short (got {len(value)} chars)"))
        elif value == "your_key_here" or value == "REPLACE_ME":
            invalid.append((var_name, config, "still contains placeholder value"))
    
    # If any problems found, show helpful error and exit
    if missing or invalid:
        print("=" * 70)
        print("⚠️  CONFIGURATION ERROR: Missing or invalid environment variables")
        print("=" * 70)
        print()
        
        if missing:
            print("Missing variables:")
            for var_name, config in missing:
                print(f"  • {var_name}")
                print(f"    {config['description']}")
                print(f"    Get one at: {config['where_to_get']}")
                print()
        
        if invalid:
            print("Invalid variables:")
            for var_name, config, reason in invalid:
                print(f"  • {var_name}: {reason}")
                print(f"    {config['description']}")
                print()
        
        print("To fix:")
        print("  1. Copy .env.example to .env")
        print("  2. Fill in your actual API keys")
        print("  3. Run this script again")
        print()
        print("=" * 70)
        sys.exit(1)
    
    # All validations passed
    print("✓ All required environment variables are present and valid")
    return True


# Call at the very start of your program
if __name__ == "__main__":
    validate_environment()
    
    # Now safely import and use your API functions
    from weather_module import get_weather
    
    print(get_weather("Dublin"))

import requests
import time

def make_api_request_with_retry(url, params, max_retries=3):
    """
    Make API request with intelligent rate limit handling.
    
    Respects Retry-After header when provided.
    Falls back to exponential backoff if no header.
    """
    
    for attempt in range(max_retries):
        try:
            response = requests.get(url, params=params, timeout=10)
            
            # Success! Return the response
            if response.ok:
                return (True, response, None)
            
            # Rate limited - handle specially
            if response.status_code == 429:
                # Check if API tells us how long to wait
                retry_after = response.headers.get("Retry-After")
                
                if retry_after:
                    # Header provided - respect it
                    wait_seconds = int(retry_after)
                    print(f"Rate limited. API says wait {wait_seconds}s...")
                else:
                    # No header - use exponential backoff
                    wait_seconds = 2 ** attempt  # 1s, 2s, 4s
                    print(f"Rate limited. Waiting {wait_seconds}s (attempt {attempt + 1}/{max_retries})...")
                
                # Don't retry if this was our last attempt
                if attempt < max_retries - 1:
                    time.sleep(wait_seconds)
                    continue
                else:
                    return (False, None, "Rate limit exceeded - max retries reached")
            
            # Authentication errors - don't retry
            if response.status_code in (401, 403):
                return (False, None, f"Authentication error {response.status_code} - check credentials")
            
            # Other error - don't retry
            return (False, None, f"Request failed with status {response.status_code}")
        
        except requests.exceptions.Timeout:
            # Timeout might be transient - retry with backoff
            if attempt < max_retries - 1:
                wait_seconds = 2 ** attempt
                print(f"Request timed out. Retrying in {wait_seconds}s...")
                time.sleep(wait_seconds)
                continue
            else:
                return (False, None, "Request timed out - max retries reached")
        
        except requests.exceptions.RequestException as e:
            # Connection errors might be transient - retry
            if attempt < max_retries - 1:
                wait_seconds = 2 ** attempt
                print(f"Connection error: {e}. Retrying in {wait_seconds}s...")
                time.sleep(wait_seconds)
                continue
            else:
                return (False, None, f"Request failed: {e}")
    
    return (False, None, "Max retries exceeded")


# Example usage
success, response, error = make_api_request_with_retry(
    url="https://api.openweathermap.org/data/2.5/weather",
    params={"q": "Dublin", "appid": "your_key", "units": "metric"}
)

if success:
    print("Got data:", response.json())
else:
    print("Failed:", error)

"""
Professional API client base class with authentication handling.
Reuse this across all your API projects.
"""
import requests
import os
import time
from typing import Tuple, Optional, Dict, Any


class APIClient:
    """
    Base class for authenticated API clients.
    Handles credential loading, validation, retries, and error handling.
    """
    
    def __init__(self, api_key_env_var: str, base_url: str):
        """
        Initialize API client with credential validation.
        
        Args:
            api_key_env_var: Name of environment variable containing API key
            base_url: Base URL for API endpoints
        """
        self.base_url = base_url
        self.api_key = os.getenv(api_key_env_var)
        
        if self.api_key is None:
            raise ValueError(
                f"API key not found. Set {api_key_env_var} environment variable."
            )
        
        if len(self.api_key) < 10:
            raise ValueError(
                f"API key appears invalid (too short). Check {api_key_env_var} value."
            )
    
    def _make_request(
        self,
        endpoint: str,
        params: Optional[Dict[str, Any]] = None,
        max_retries: int = 3
    ) -> Tuple[bool, Optional[dict], str]:
        """
        Make authenticated API request with retry logic.
        
        Returns: (success, data, message)
        """
        url = f"{self.base_url}{endpoint}"
        
        for attempt in range(max_retries):
            try:
                response = requests.get(url, params=params, timeout=10)
                
                # Success
                if response.ok:
                    try:
                        data = response.json()
                        return (True, data, "Success")
                    except ValueError:
                        return (False, None, "Invalid JSON in response")
                
                # Handle authentication errors
                if response.status_code == 401:
                    return (False, None, "Authentication failed - check API key")
                
                elif response.status_code == 403:
                    return (False, None, "Access forbidden - insufficient permissions")
                
                # Handle rate limiting with retry
                elif response.status_code == 429:
                    retry_after = response.headers.get("Retry-After")
                    
                    if attempt < max_retries - 1:
                        wait_seconds = int(retry_after) if retry_after else 2 ** attempt
                        print(f"Rate limited. Waiting {wait_seconds}s...")
                        time.sleep(wait_seconds)
                        continue
                    else:
                        return (False, None, "Rate limit exceeded - max retries reached")
                
                # Other errors - don't retry
                else:
                    return (False, None, f"Request failed: {response.status_code}")
            
            except requests.exceptions.Timeout:
                if attempt < max_retries - 1:
                    wait_seconds = 2 ** attempt
                    print(f"Timeout. Retrying in {wait_seconds}s...")
                    time.sleep(wait_seconds)
                    continue
                else:
                    return (False, None, "Request timed out")
            
            except requests.exceptions.RequestException as e:
                if attempt < max_retries - 1:
                    wait_seconds = 2 ** attempt
                    print(f"Error: {e}. Retrying in {wait_seconds}s...")
                    time.sleep(wait_seconds)
                    continue
                else:
                    return (False, None, f"Request failed: {e}")
        
        return (False, None, "Max retries exceeded")


class WeatherClient(APIClient):
    """
    OpenWeatherMap API client - inherits authentication handling.
    """
    
    def __init__(self):
        super().__init__(
            api_key_env_var="OPENWEATHER_API_KEY",
            base_url="https://api.openweathermap.org/data/2.5"
        )
    
    def get_weather(self, city: str) -> Tuple[bool, Optional[str], str]:
        """Get current weather for a city."""
        params = {
            "q": city,
            "appid": self.api_key,
            "units": "metric"
        }
        
        success, data, message = self._make_request("/weather", params)
        
        if not success:
            return (False, None, message)
        
        # Extract weather data defensively
        main = data.get("main", {})
        weather_list = data.get("weather", [])
        
        if not isinstance(main, dict) or not weather_list:
            return (False, None, "Invalid response structure")
        
        temp = main.get("temp", "Unknown")
        description = weather_list[0].get("description", "Unknown")
        
        result = f"{city}: {temp}°C, {description}"
        return (True, result, "Success")


# Example usage
if __name__ == "__main__":
    from dotenv import load_dotenv
    load_dotenv()
    
    try:
        weather = WeatherClient()
        
        for city in ["Dublin", "London", "Paris"]:
            success, data, message = weather.get_weather(city)
            if success:
                print(f"✓ {data}")
            else:
                print(f"✗ {city}: {message}")
    
    except ValueError as e:
        print(f"Configuration error: {e}")