# ❌ WRONG
print("🚀 Starting process...")
print("✨ Success!")

# ✅ CORRECT
print("Starting process...")
print("Success!")

# ✅ Correct import order
from __future__ import annotations  # Future imports first

import json  # Standard library
import re
from typing import Any

import pytest  # Third-party packages
import requests

from python_modern_template import helper  # Local imports
from python_modern_template.utils import process_data

from __future__ import annotations  # For forward references

from typing import Any

def process_data(
    input_str: str,
    options: dict[str, Any] | None = None,
    max_length: int = 100,
) -> list[str]:
    """Process input data with options.

    Args:
        input_str: Input data to process
        options: Optional processing options
        max_length: Maximum length for output items

    Returns:
        List of processed strings
    """
    ...

# ✅ Use new union syntax
def get_value(key: str) -> str | None:
    ...

# ❌ Old syntax (avoid)
from typing import Optional
def get_value(key: str) -> Optional[str]:
    ...

# ✅ Use built-in generics
def process_items(items: list[str]) -> dict[str, int]:
    ...

# ❌ Old syntax (avoid)
from typing import List, Dict
def process_items(items: List[str]) -> Dict[str, int]:
    ...

from typing import Any, Callable, Protocol

# Callable types
def apply_function(func: Callable[[int, int], int], a: int, b: int) -> int:
    return func(a, b)

# Protocol for structural typing
class HasName(Protocol):
    name: str

def greet(obj: HasName) -> str:
    return f"Hello, {obj.name}"

# TypedDict for structured dicts
from typing import TypedDict

class UserData(TypedDict):
    name: str
    age: int
    email: str | None

def calculate_total(
    items: list[dict[str, Any]],
    tax_rate: float = 0.1,
    discount: float = 0.0,
) -> float:
    """Calculate total price with tax and discount.

    This function processes a list of items, applies tax and discount,
    and returns the final total price.

    Args:
        items: List of item dictionaries with 'price' key
        tax_rate: Tax rate as decimal (default 0.1 = 10%)
        discount: Discount as decimal (default 0.0 = no discount)

    Returns:
        Total price after tax and discount

    Raises:
        ValueError: If items is empty
        KeyError: If item missing 'price' key

    Example:
        >>> items = [{"name": "Book", "price": 10.00}]
        >>> calculate_total(items, tax_rate=0.1)
        11.00
    """
    if not items:
        raise ValueError("Items list cannot be empty")

    subtotal = sum(item["price"] for item in items)
    total = subtotal * (1 + tax_rate) * (1 - discount)
    return round(total, 2)

"""Module for user authentication and authorization.

This module provides functions for:
- User login/logout
- Password validation
- Token generation
- Permission checking

Typical usage example:

    from python_modern_template.auth import authenticate_user

    user = authenticate_user(username, password)
    if user:
        print(f"Welcome, {user.name}")
"""

class UserValidator:
    """Validates user data before creating user accounts.

    This class provides validation for:
    - Username format and uniqueness
    - Email format
    - Password strength
    - Age requirements

    Attributes:
        min_age: Minimum age for user registration
        password_min_length: Minimum password length

    Example:
        >>> validator = UserValidator(min_age=18)
        >>> validator.validate_username("john_doe")
        True
    """

    def __init__(self, min_age: int = 13) -> None:
        """Initialize validator with age requirement.

        Args:
            min_age: Minimum age for registration (default 13)
        """
        self.min_age = min_age

# ✅ Correct - import from package name
from python_modern_template import function_name
from python_modern_template.module import ClassName

# ❌ Wrong - don't use src prefix
from src.python_modern_template import function_name

# File: src/python_modern_template/__init__.py

"""Modern Python template package."""

from .main import generate_blog
from .validators import validate_email, validate_phone

__version__ = "0.1.0"

__all__ = [
    "generate_blog",
    "validate_email",
    "validate_phone",
]

# ❌ Bad - duplicate logic
def process_user(name: str) -> str:
    return name.strip().lower().replace(" ", "_")

def process_product(name: str) -> str:
    return name.strip().lower().replace(" ", "_")

# ✅ Good - shared logic
def normalize_name(name: str) -> str:
    """Normalize name to lowercase with underscores."""
    return name.strip().lower().replace(" ", "_")

def process_user(name: str) -> str:
    """Process user name."""
    return normalize_name(name)

def process_product(name: str) -> str:
    """Process product name."""
    return normalize_name(name)

# ✅ Good - single responsibility
def read_file(path: str) -> str:
    """Read file contents."""
    with open(path) as f:
        return f.read()

def parse_config(content: str) -> dict[str, Any]:
    """Parse config from string."""
    return json.loads(content)

def load_config(path: str) -> dict[str, Any]:
    """Load and parse config file."""
    content = read_file(path)
    return parse_config(content)

# ❌ Implicit behavior
def process(data, flag=True):
    if flag:
        return data.upper()
    return data

# ✅ Explicit, testable
def uppercase(data: str) -> str:
    """Convert data to uppercase."""
    return data.upper()

def process(data: str, transform: bool = True) -> str:
    """Process data with optional transformation.

    Args:
        data: Input data
        transform: Apply uppercase transformation

    Returns:
        Processed data
    """
    if transform:
        return uppercase(data)
    return data

# ✅ Good - specific exceptions
def divide(a: float, b: float) -> float:
    """Divide two numbers.

    Args:
        a: Numerator
        b: Denominator

    Returns:
        Result of division

    Raises:
        ValueError: If b is zero
    """
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

# ❌ Bad - bare except
try:
    result = risky_operation()
except:  # Never do this!
    pass

# ✅ Good - specific exceptions
try:
    result = risky_operation()
except ValueError as e:
    logger.error(f"Invalid value: {e}")
    raise
except IOError as e:
    logger.error(f"IO error: {e}")
    raise

# ❌ Bad - hardcoded secrets
API_KEY = "sk-1234567890abcdef"
DATABASE_URL = "postgresql://user:password@localhost/db"

# ✅ Good - environment variables
import os

API_KEY = os.environ["API_KEY"]
DATABASE_URL = os.environ["DATABASE_URL"]

# ✅ Always validate user input
def create_user(email: str, age: int) -> User:
    """Create new user with validation.

    Args:
        email: User email address
        age: User age

    Returns:
        Created user object

    Raises:
        ValueError: If email invalid or age < 0
    """
    if not validate_email(email):
        raise ValueError(f"Invalid email: {email}")

    if age < 0:
        raise ValueError(f"Invalid age: {age}")

    return User(email=email, age=age)

# ❌ Bad - SQL injection risk
def get_user(user_id: str) -> User:
    query = f"SELECT * FROM users WHERE id = {user_id}"  # Dangerous!
    return db.execute(query)

# ✅ Good - parameterized queries
def get_user(user_id: int) -> User:
    query = "SELECT * FROM users WHERE id = ?"
    return db.execute(query, (user_id,))

# snake_case for variables and functions
user_name = "John"
total_count = 100

def calculate_total_price(items: list[Item]) -> float:
    """Calculate total price."""
    ...

# PascalCase for classes
class UserValidator:
    """Validates user data."""
    ...

class EmailProcessor:
    """Processes email messages."""
    ...

# UPPER_SNAKE_CASE for constants
MAX_RETRIES = 3
DEFAULT_TIMEOUT = 30
API_BASE_URL = "https://api.example.com"

class MyClass:
    """Example class with private members."""

    def __init__(self) -> None:
        """Initialize class."""
        self._internal_value = 0  # Single underscore for internal use
        self.__private_value = 0  # Double underscore for name mangling

    def public_method(self) -> int:
        """Public method."""
        return self._internal_value

    def _internal_method(self) -> None:
        """Internal method (not part of public API)."""
        ...