Python Code Generator (Free AI Tool)

Plain English:
"Create a function that reads a CSV file using pandas,
filters rows where age is above 25, calculates the average
salary, and returns the result with proper error handling."

import pandas as pd
from pathlib import Path
from typing import Optional

def calculate_average_salary(file_path: str, age_threshold: int = 25) -> Optional[float]:
    """
    Calculate average salary for people above specified age.
    
    Args:
        file_path: Path to CSV file containing age and salary columns
        age_threshold: Minimum age to include (default: 25)
    
    Returns:
        Average salary as float, or None if no matching records
    
    Raises:
        FileNotFoundError: If CSV file does not exist
        ValueError: If required columns are missing
    """
    try:
        # Validate file exists
        if not Path(file_path).exists():
            raise FileNotFoundError(f"CSV file not found: {file_path}")
        
        # Read CSV with pandas
        df = pd.read_csv(file_path)
        
        # Validate required columns
        required_cols = ["age", "salary"]
        missing_cols = set(required_cols) - set(df.columns)
        if missing_cols:
            raise ValueError(f"Missing columns: {missing_cols}")
        
        # Filter by age and calculate average
        filtered_df = df[df["age"] > age_threshold]
        
        if filtered_df.empty:
            return None
        
        return float(filtered_df["salary"].mean())
    
    except pd.errors.EmptyDataError:
        raise ValueError("CSV file is empty")
    except Exception as e:
        raise RuntimeError(f"Error processing data: {e}")

Plain English:
"Create an async function that fetches user data from a REST API,
retries 3 times on failure with exponential backoff,
and returns JSON data or raises an exception."

import asyncio
import aiohttp
from typing import Dict, Any
from aiohttp import ClientSession, ClientError
import logging

logger = logging.getLogger(__name__)

async def fetch_user_data(
    user_id: int,
    api_url: str = "https://api.example.com/users",
    max_retries: int = 3,
    base_delay: float = 1.0
) -> Dict[str, Any]:
    """
    Fetch user data from REST API with retry logic.
    
    Implements exponential backoff for failed requests.
    Retries on network errors and 5xx server errors.
    
    Args:
        user_id: Unique identifier for the user
        api_url: Base URL of the API endpoint
        max_retries: Maximum number of retry attempts (default: 3)
        base_delay: Initial delay in seconds for exponential backoff
    
    Returns:
        Dictionary containing user data from API response
    
    Raises:
        ValueError: If user_id is invalid
        ClientError: If all retry attempts fail
    """
    if user_id <= 0:
        raise ValueError("user_id must be positive integer")
    
    url = f"{api_url}/{user_id}"
    
    async with ClientSession() as session:
        for attempt in range(max_retries):
            try:
                async with session.get(url, timeout=aiohttp.ClientTimeout(total=10)) as response:
                    # Raise for 4xx client errors (no retry)
                    if 400 <= response.status < 500:
                        response.raise_for_status()
                    
                    # Success case
                    if response.status == 200:
                        data = await response.json()
                        logger.info(f"Successfully fetched user {user_id}")
                        return data
                    
                    # Retry for 5xx server errors
                    if response.status >= 500:
                        raise ClientError(f"Server error: {response.status}")
            
            except (ClientError, asyncio.TimeoutError) as e:
                if attempt == max_retries - 1:
                    logger.error(f"Failed to fetch user {user_id} after {max_retries} attempts")
                    raise
                
                # Exponential backoff: 1s, 2s, 4s
                delay = base_delay * (2 ** attempt)
                logger.warning(f"Retry {attempt + 1}/{max_retries} after {delay}s: {e}")
                await asyncio.sleep(delay)
        
        raise ClientError(f"Max retries ({max_retries}) exceeded for user {user_id}")