# ❌ Bad: Unclear, no documentation
def f(x,y):return x if x>y else y

# ✓ Good: Clear, documented
def get_maximum(a: int, b: int) -> int:
    """Return the maximum of two numbers.

    Args:
        a: First number
        b: Second number

    Returns:
        The larger of a and b
    """
    return a if a > b else b

def read_file(path: str) -> str:
    """Read file contents safely."""
    try:
        with open(path, 'r', encoding='utf-8') as f:
            return f.read()
    except FileNotFoundError:
        raise ValueError(f"File not found: {path}")
    except PermissionError:
        raise ValueError(f"Permission denied: {path}")
    except Exception as e:
        raise ValueError(f"Error reading file: {e}")

# Function with single responsibility
def validate_email(email: str) -> bool:
    """Validate email format."""
    import re
    pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$'
    return bool(re.match(pattern, email))

# Easy to test
def test_validate_email():
    assert validate_email("user@example.com") == True
    assert validate_email("invalid") == False

from typing import List, Dict, Any
import json

def filter_users_by_age(
    users: List[Dict[str, Any]],
    min_age: int,
    max_age: int
) -> List[Dict[str, Any]]:
    """Filter users by age range.

    Args:
        users: List of user dictionaries with 'age' field
        min_age: Minimum age (inclusive)
        max_age: Maximum age (inclusive)

    Returns:
        Filtered list of users within age range

    Raises:
        ValueError: If min_age > max_age

    Example:
        >>> users = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 35}]
        >>> filter_users_by_age(users, 20, 30)
        [{'name': 'Alice', 'age': 25}]
    """
    if min_age > max_age:
        raise ValueError(f"min_age ({min_age}) cannot exceed max_age ({max_age})")

    return [
        user for user in users
        if 'age' in user and min_age <= user['age'] <= max_age
    ]

# Tests
def test_filter_users_by_age():
    users = [
        {'name': 'Alice', 'age': 25},
        {'name': 'Bob', 'age': 35},
        {'name': 'Charlie', 'age': 45},
    ]

    result = filter_users_by_age(users, 20, 40)
    assert len(result) == 2
    assert result[0]['name'] == 'Alice'
    assert result[1]['name'] == 'Bob'

    # Edge case: empty list
    assert filter_users_by_age([], 20, 40) == []

    # Edge case: invalid range
    try:
        filter_users_by_age(users, 40, 20)
        assert False, "Should raise ValueError"
    except ValueError:
        pass

if __name__ == "__main__":
    test_filter_users_by_age()
    print("All tests passed!")

/**
 * HTTP client for REST API interactions
 */
class ApiClient {
  /**
   * @param {string} baseUrl - Base URL for API
   * @param {string} apiKey - API authentication key
   */
  constructor(baseUrl, apiKey) {
    this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
    this.apiKey = apiKey;
  }

  /**
   * Make GET request
   * @param {string} endpoint - API endpoint
   * @returns {Promise<any>} Response data
   */
  async get(endpoint) {
    const url = `${this.baseUrl}${endpoint}`;

    try {
      const response = await fetch(url, {
        method: 'GET',
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json',
        },
      });

      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }

      return await response.json();
    } catch (error) {
      throw new Error(`API request failed: ${error.message}`);
    }
  }

  /**
   * Make POST request
   * @param {string} endpoint - API endpoint
   * @param {object} data - Request payload
   * @returns {Promise<any>} Response data
   */
  async post(endpoint, data) {
    const url = `${this.baseUrl}${endpoint}`;

    try {
      const response = await fetch(url, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(data),
      });

      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }

      return await response.json();
    } catch (error) {
      throw new Error(`API request failed: ${error.message}`);
    }
  }
}

// Usage example
const client = new ApiClient('https://api.example.com', 'your-api-key');

// GET request
const users = await client.get('/users');
console.log(users);

// POST request
const newUser = await client.post('/users', {
  name: 'John Doe',
  email: 'john@example.com'
});
console.log(newUser);

-- Create users table with proper constraints
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(50) UNIQUE NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    password_hash VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    is_active BOOLEAN DEFAULT TRUE,

    -- Constraints
    CONSTRAINT email_format CHECK (email ~* '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}$'),
    CONSTRAINT username_length CHECK (LENGTH(username) >= 3)
);

-- Create index for faster lookups
CREATE INDEX idx_users_email ON users(email);
CREATE INDEX idx_users_username ON users(username);
CREATE INDEX idx_users_active ON users(is_active) WHERE is_active = TRUE;

-- Insert user with validation
INSERT INTO users (username, email, password_hash)
VALUES ($1, $2, $3)
ON CONFLICT (email) DO NOTHING
RETURNING id, username, email, created_at;

-- Query active users with pagination
SELECT
    id,
    username,
    email,
    created_at,
    updated_at
FROM users
WHERE is_active = TRUE
ORDER BY created_at DESC
LIMIT $1 OFFSET $2;

-- Update user with timestamp
UPDATE users
SET
    username = $1,
    email = $2,
    updated_at = CURRENT_TIMESTAMP
WHERE id = $3 AND is_active = TRUE
RETURNING id, username, email, updated_at;

class DatabaseConnection:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance.connection = cls._create_connection()
        return cls._instance

    @staticmethod
    def _create_connection():
        # Create database connection
        pass

class QueryBuilder {
  constructor() {
    this.query = { select: [], where: [], orderBy: [] };
  }

  select(...fields) {
    this.query.select.push(...fields);
    return this;
  }

  where(condition) {
    this.query.where.push(condition);
    return this;
  }

  orderBy(field, direction = 'ASC') {
    this.query.orderBy.push({ field, direction });
    return this;
  }

  build() {
    return this.query;
  }
}

// Usage
const query = new QueryBuilder()
  .select('id', 'name')
  .where('age > 18')
  .orderBy('name')
  .build();