12 Prompts for GitHub Copilot: From Commit Messages to Code Review

Given the following diff, generate a concise commit message following the Conventional Commits format (type: description). The diff is:
[PASTE YOUR DIFF]

feat(auth): add error handling for login endpoint

- Add try-catch block to login function
- Return 401 for invalid credentials
- Log errors to console for debugging

Explain the following code as if I were a beginner developer. Include the purpose of each major section, and highlight any potential pitfalls:
[PASTE CODE]

This code defines a decorator named `timer`. The decorator wraps a function so that when you call it, it prints how long the function took to run. The `@functools.wraps` line preserves the original function's metadata (name, docstring). A potential pitfall: if the wrapped function is a generator, the timing will only measure the creation of the generator, not its iteration.

Write pytest unit tests for the following function. Include edge cases such as empty input, None, and large numbers. Use descriptive test function names:
[PASTE FUNCTION]

def test_factorial_zero():
    assert factorial(0) == 1

def test_factorial_positive():
    assert factorial(5) == 120

def test_factorial_large():
    assert factorial(10) == 3628800

def test_factorial_negative():
    with pytest.raises(ValueError):
        factorial(-1)

Refactor the following function to improve readability by extracting helper functions. Use descriptive names for each helper. Keep the same external behavior:
[PASTE CODE]

def validate_user_input(data):
    errors = []
    if not _is_email_valid(data.get('email', '')):
        errors.append('Invalid email format')
    if not _is_age_valid(data.get('age', -1)):
        errors.append('Age must be between 0 and 150')
    return errors

def _is_email_valid(email):
    return '@' in email and '.' in email

def _is_age_valid(age):
    return 0 <= age <= 150

Analyze this code for common code smells: long method, large class, duplicate code, magic numbers, and poor naming. For each smell found, suggest a specific improvement:
[PASTE CODE]

- **Long Method**: The `process_order` method is 180 lines. Suggest extracting the payment validation and shipping logic into separate methods.
- **Magic Numbers**: Line 42 uses `0.15` for tax rate. Replace with a named constant `TAX_RATE = 0.15`.
- **Duplicate Code**: The discount calculation appears three times. Extract into a `_calculate_discount` helper.

Generate Google-style docstrings for each function in this module. Also create a README.md section that explains the module's purpose and how to use it:
[PASTE MODULE CODE]

def fetch_data(url: str, timeout: int = 10) -> dict:
    """Fetch JSON data from a URL.

    Args:
        url (str): The endpoint URL.
        timeout (int, optional): Request timeout in seconds. Defaults to 10.

    Returns:
        dict: Parsed JSON response.

    Raises:
        HTTPError: If the request fails.
    """

Act as a senior security engineer. Review this code for OWASP Top 10 vulnerabilities, particularly SQL injection, XSS, and insecure deserialization. For each vulnerability, explain the risk and provide a fix:
[PASTE CODE]

- **SQL Injection (Critical)**: Line 15 uses f-string to build SQL query. Use parameterized queries instead.
  Fix: `cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))`
- **XSS (High)**: Line 22 renders user input directly in HTML. Use `escape()` or a template engine's auto-escaping.

Analyze this function for performance issues. Look for unnecessary loops, redundant database calls, and inefficient data structures. Suggest optimized alternatives with time complexity analysis:
[PASTE CODE]

- **Inefficient Loop**: The nested loop results in O(n²) complexity. Replace with a set for O(n).
- **Redundant DB Calls**: The function queries the database inside the loop. Use a single JOIN query instead.
  Optimized version:

Create a code review checklist for a Python web application using Flask and PostgreSQL. Cover: code style, security, performance, error handling, and testing. Format as a table with columns: Category, Check, Example of Good Practice, Example of Bad Practice.

Convert the following JavaScript function to idiomatic Python 3. Use type hints, list comprehensions where appropriate, and follow PEP 8. Preserve the exact logic:
[PASTE JS CODE]

from typing import List

def process_data(items: List[int]) -> List[int]:
    return [x * 2 for x in items if x > 0]

Generate a pull request description based on these changes. Include: summary of changes, motivation, testing steps, and any breaking changes. The branch modifies authentication middleware and adds a rate limiter.
[PASTE SUMMARY OF CHANGES]

## Summary
Adds rate limiting to the authentication middleware to prevent brute-force attacks.

## Changes
- Introduced `RateLimiter` class using Redis for distributed rate counting.
- Modified `auth_middleware.py` to check rate limit before validating token.
- Added unit tests for rate limiter with mocked Redis.

## Testing
1. Run `pytest tests/test_rate_limiter.py`.
2. Send 10 rapid requests to `/api/login` — the 11th should return 429.

## Breaking Changes
None.

Act as a senior developer reviewing my code. For each issue, provide a comment explaining the problem and a suggestion. Then I will respond with my fix. Start with the first issue in this code:
[PASTE CODE]

**Comment 1:** The function `calculate_total` modifies the input list `items` by appending a tax line. This is a side effect that callers may not expect. Consider returning a new list instead.