# This would be run in your command line
# pip install pytest

# You can verify the installation with:
import pytest
print(f"pytest version: {pytest.__version__}")
# pytest version: 7.3.1

# Save this as data_functions.py
from typing import List, Union, Dict, Any

def calculate_average(numbers: List[Union[int, float]]) -> float:
    """Calculate the average of a list of numbers."""
    if not numbers:
        return 0.0
    return sum(numbers) / len(numbers)

# Example usage
if __name__ == "__main__":
    sample_data = [10, 15, 20, 25, 30]
    avg = calculate_average(sample_data)
    print(f"The average of {sample_data} is {avg}")
    # The average of [10, 15, 20, 25, 30] is 20.0

# Save this as test_data_functions.py
from typing import List, Union
import pytest
from data_functions import calculate_average

def test_calculate_average() -> None:
    """Test that the calculate_average function works correctly."""
    # Test with whole numbers
    test_data: List[int] = [10, 20, 30, 40, 50]
    result = calculate_average(test_data)
    print(f"Testing with {test_data}, got {result}")
    assert result == 30.0

    # Test with decimal numbers
    test_data_decimal: List[float] = [1.5, 2.5, 3.5]
    result_decimal = calculate_average(test_data_decimal)
    print(f"Testing with {test_data_decimal}, got {result_decimal}")
    assert result_decimal == 2.5

    # Test with empty list
    empty_list: List[float] = []
    result_empty = calculate_average(empty_list)
    print(f"Testing with {empty_list}, got {result_empty}")
    assert result_empty == 0.0

# This won't be executed when running with pytest,
# but lets us run the test directly if needed
if __name__ == "__main__":
    test_calculate_average()
    print("All tests passed!")
    # Testing with [10, 20, 30, 40, 50], got 30.0
    # Testing with [1.5, 2.5, 3.5], got 2.5
    # Testing with [], got 0.0
    # All tests passed!

# From the command line
pytest test_data_functions.py -v

# Save this as test_failures.py
from typing import List
import pytest

def add_numbers(a: int, b: int) -> int:
    """Add two numbers together."""
    # Let's introduce a bug to see test failure
    return a - b  # Bug: subtraction instead of addition

def test_add_numbers() -> None:
    """Test the add_numbers function."""
    result = add_numbers(5, 3)
    print(f"5 + 3 = {result}")
    assert result == 8, f"Expected 8 but got {result}"

def test_add_negative_numbers() -> None:
    """Test adding negative numbers."""
    result = add_numbers(-2, -3)
    print(f"-2 + -3 = {result}")
    assert result == -5, f"Expected -5 but got {result}"

if __name__ == "__main__":
    # Running directly will show us the print outputs
    test_add_numbers()
    # 5 + 3 = 2
    # AssertionError: Expected 8 but got 2

# Save this as test_calculations.py
from typing import List, Dict, Any, Union
import pytest

# Functions to test
def calculate_sum(numbers: List[Union[int, float]]) -> Union[int, float]:
    """Calculate the sum of a list of numbers."""
    return sum(numbers)

def calculate_product(numbers: List[Union[int, float]]) -> Union[int, float]:
    """Calculate the product of a list of numbers."""
    if not numbers:
        return 0
    result = 1
    for num in numbers:
        result *= num
    return result

# Test class for grouping related tests
class TestCalculations:
    """Tests for calculation functions."""

    def test_sum_positive_numbers(self) -> None:
        """Test sum with positive numbers."""
        data = [1, 2, 3, 4, 5]
        result = calculate_sum(data)
        print(f"Sum of {data} = {result}")
        assert result == 15

    def test_sum_negative_numbers(self) -> None:
        """Test sum with negative numbers."""
        data = [-1, -2, -3]
        result = calculate_sum(data)
        print(f"Sum of {data} = {result}")
        assert result == -6

    def test_product_positive_numbers(self) -> None:
        """Test product with positive numbers."""
        data = [2, 3, 4]
        result = calculate_product(data)
        print(f"Product of {data} = {result}")
        assert result == 24

    def test_product_with_zero(self) -> None:
        """Test product with zero in the list."""
        data = [2, 0, 4]
        result = calculate_product(data)
        print(f"Product of {data} = {result}")
        assert result == 0

    def test_product_empty_list(self) -> None:
        """Test product with empty list."""
        data: List[int] = []
        result = calculate_product(data)
        print(f"Product of {data} = {result}")
        assert result == 0

if __name__ == "__main__":
    # Running the test class directly for demonstration
    test = TestCalculations()
    test.test_sum_positive_numbers()
    test.test_sum_negative_numbers()
    test.test_product_positive_numbers()
    test.test_product_with_zero()
    test.test_product_empty_list()
    print("All tests passed!")
    # Sum of [1, 2, 3, 4, 5] = 15
    # Sum of [-1, -2, -3] = -6
    # Product of [2, 3, 4] = 24
    # Product of [2, 0, 4] = 0
    # Product of [] = 0
    # All tests passed!

# Save as test_assertions.py
from typing import Dict, List, Any
import pytest

def test_different_assertions() -> None:
    """Demonstrate different pytest assertion methods."""

    # Equal
    result = 5 + 5
    print(f"Testing 5 + 5 = {result} equals 10")
    assert result == 10

    # Not equal
    value = "hello"
    print(f"Testing '{value}' is not equal to 'world'")
    assert value != "world"

    # True/False
    condition = 5 > 3
    print(f"Testing 5 > 3 is {condition}")
    assert condition is True

    # In (membership)
    items = [1, 2, 3]
    print(f"Testing 2 is in {items}")
    assert 2 in items

    # Instance check
    data_dict: Dict[str, int] = {"a": 1, "b": 2}
    print(f"Testing {data_dict} is a dictionary")
    assert isinstance(data_dict, dict)

    # Exception check - using a context manager
    def divide_by_zero() -> float:
        return 1 / 0

    print("Testing that dividing by zero raises ZeroDivisionError")
    with pytest.raises(ZeroDivisionError):
        divide_by_zero()

if __name__ == "__main__":
    test_different_assertions()
    print("All assertions passed!")
    # Testing 5 + 5 = 10 equals 10
    # Testing 'hello' is not equal to 'world'
    # Testing 5 > 3 is True
    # Testing 2 is in [1, 2, 3]
    # Testing {'a': 1, 'b': 2} is a dictionary
    # Testing that dividing by zero raises ZeroDivisionError
    # All assertions passed!

# Save as data_transformations.py
from typing import Dict, List, Any, Union, Optional

def clean_numeric_column(values: List[Any]) -> List[Optional[float]]:
    """Convert a list of values to floats, replacing non-numeric values with None."""
    cleaned = []
    for val in values:
        try:
            if val is None or val == "":
                cleaned.append(None)
            else:
                cleaned.append(float(val))
        except (ValueError, TypeError):
            cleaned.append(None)
    return cleaned

def calculate_growth_rate(original: float, new: float) -> float:
    """Calculate the growth rate from original to new value."""
    if original <= 0:
        raise ValueError("Original value must be positive for growth rate calculation")
    return (new - original) / original * 100.0

def categorize_values(values: List[float], thresholds: Dict[str, float]) -> List[str]:
    """Categorize values based on thresholds."""
    result = []
    for val in values:
        for category, threshold in sorted(thresholds.items(),
                                         key=lambda x: x[1], reverse=True):
            if val >= threshold:
                result.append(category)
                break
        else:  # This else belongs to the for loop (executes if no break)
            result.append("below_threshold")
    return result

# Example usage
if __name__ == "__main__":
    # Clean numeric column
    raw_data = ["10.5", "", "not a number", "20", None, "30.5"]
    cleaned = clean_numeric_column(raw_data)
    print(f"Raw data: {raw_data}")
    print(f"Cleaned: {cleaned}")

    # Growth rate
    old_value = 100
    new_value = 120
    growth = calculate_growth_rate(old_value, new_value)
    print(f"Growth from {old_value} to {new_value}: {growth}%")

    # Categorize values
    values = [15, 35, 75, 5, 50]
    thresholds = {"high": 70, "medium": 30, "low": 10}
    categories = categorize_values(values, thresholds)
    print(f"Values: {values}")
    print(f"Categories: {categories}")

    # Raw data: ['10.5', '', 'not a number', '20', None, '30.5']
    # Cleaned: [10.5, None, None, 20.0, None, 30.5]
    # Growth from 100 to 120: 20.0%
    # Values: [15, 35, 75, 5, 50]
    # Categories: ['low', 'medium', 'high', 'below_threshold', 'medium']

# Save as test_data_transformations.py
from typing import Dict, List, Any, Optional
import pytest
from data_transformations import (
    clean_numeric_column,
    calculate_growth_rate,
    categorize_values
)

class TestCleanNumericColumn:
    """Tests for the clean_numeric_column function."""

    def test_valid_numbers(self) -> None:
        """Test with valid numeric strings."""
        data = ["10", "20.5", "30"]
        result = clean_numeric_column(data)
        print(f"Cleaning {data} gives {result}")
        assert result == [10.0, 20.5, 30.0]

    def test_invalid_inputs(self) -> None:
        """Test with invalid inputs."""
        data = ["not a number", "", None]
        result = clean_numeric_column(data)
        print(f"Cleaning {data} gives {result}")
        assert result == [None, None, None]

    def test_mixed_inputs(self) -> None:
        """Test with a mix of valid and invalid inputs."""
        data = ["10.5", "not a number", "20", None]
        result = clean_numeric_column(data)
        print(f"Cleaning {data} gives {result}")
        assert result == [10.5, None, 20.0, None]

class TestCalculateGrowthRate:
    """Tests for the calculate_growth_rate function."""

    def test_positive_growth(self) -> None:
        """Test with positive growth."""
        original, new = 100, 150
        result = calculate_growth_rate(original, new)
        print(f"Growth from {original} to {new}: {result}%")
        assert result == 50.0

    def test_negative_growth(self) -> None:
        """Test with negative growth (decline)."""
        original, new = 100, 80
        result = calculate_growth_rate(original, new)
        print(f"Growth from {original} to {new}: {result}%")
        assert result == -20.0

    def test_zero_growth(self) -> None:
        """Test with no growth."""
        original, new = 100, 100
        result = calculate_growth_rate(original, new)
        print(f"Growth from {original} to {new}: {result}%")
        assert result == 0.0

    def test_invalid_original(self) -> None:
        """Test with invalid original value."""
        original, new = 0, 100
        print(f"Testing growth from {original} to {new} raises ValueError")
        with pytest.raises(ValueError):
            calculate_growth_rate(original, new)

class TestCategorizeValues:
    """Tests for the categorize_values function."""

    def test_basic_categorization(self) -> None:
        """Test basic categorization with distinct values."""
        values: List[float] = [10, 40, 80]
        thresholds: Dict[str, float] = {"high": 70, "medium": 30, "low": 10}
        result = categorize_values(values, thresholds)
        print(f"Categorizing {values} with thresholds {thresholds}")
        print(f"Results: {result}")
        assert result == ["low", "medium", "high"]

    def test_below_all_thresholds(self) -> None:
        """Test values below all thresholds."""
        values: List[float] = [5, 8, 9]
        thresholds: Dict[str, float] = {"high": 70, "medium": 30, "low": 10}
        result = categorize_values(values, thresholds)
        print(f"Categorizing {values} with thresholds {thresholds}")
        print(f"Results: {result}")
        assert result == ["below_threshold", "below_threshold", "below_threshold"]

    def test_edge_cases(self) -> None:
        """Test edge cases (values exactly at thresholds)."""
        values: List[float] = [10, 30, 70]
        thresholds: Dict[str, float] = {"high": 70, "medium": 30, "low": 10}
        result = categorize_values(values, thresholds)
        print(f"Categorizing {values} with thresholds {thresholds}")
        print(f"Results: {result}")
        assert result == ["low", "medium", "high"]

if __name__ == "__main__":
    # Run tests manually (pytest would run them automatically)
    # Clean numeric column tests
    clean_tests = TestCleanNumericColumn()
    clean_tests.test_valid_numbers()
    clean_tests.test_invalid_inputs()
    clean_tests.test_mixed_inputs()

    # Growth rate tests
    growth_tests = TestCalculateGrowthRate()
    growth_tests.test_positive_growth()
    growth_tests.test_negative_growth()
    growth_tests.test_zero_growth()

    try:
        growth_tests.test_invalid_original()
        print("Error: test_invalid_original should have raised an exception")
    except AssertionError:
        print("test_invalid_original correctly caught the ValueError")

    # Categorize values tests
    cat_tests = TestCategorizeValues()
    cat_tests.test_basic_categorization()
    cat_tests.test_below_all_thresholds()
    cat_tests.test_edge_cases()

    print("All tests passed!")

    # Cleaning ['10', '20.5', '30'] gives [10.0, 20.5, 30.0]
    # Cleaning ['not a number', '', None] gives [None, None, None]
    # Cleaning ['10.5', 'not a number', '20', None] gives [10.5, None, 20.0, None]
    # Growth from 100 to 150: 50.0%
    # Growth from 100 to 80: -20.0%
    # Growth from 100 to 100: 0.0%
    # Testing growth from 0 to 100 raises ValueError
    # test_invalid_original correctly caught the ValueError
    # Categorizing [10, 40, 80] with thresholds {'high': 70, 'medium': 30, 'low': 10}
    # Results: ['low', 'medium', 'high']
    # Categorizing [5, 8, 9] with thresholds {'high': 70, 'medium': 30, 'low': 10}
    # Results: ['below_threshold', 'below_threshold', 'below_threshold']
    # Categorizing [10, 30, 70] with thresholds {'high': 70, 'medium': 30, 'low': 10}
    # Results: ['low', 'medium', 'high']
    # All tests passed!

# Save as test_exceptions.py
from typing import List, Any
import pytest

def parse_int_safely(value: Any) -> int:
    """Parse a value to integer, raising a ValueError with a custom message if invalid."""
    if value is None:
        raise ValueError("Cannot parse None to int")
    try:
        return int(value)
    except (ValueError, TypeError):
        raise ValueError(f"Cannot parse '{value}' to int")

def test_parse_int_valid() -> None:
    """Test parsing valid integers."""
    assert parse_int_safely(5) == 5
    assert parse_int_safely("10") == 10
    print("Valid integer parsing works!")

def test_parse_int_none() -> None:
    """Test that passing None raises the correct exception."""
    print("Testing that parse_int_safely(None) raises ValueError")
    with pytest.raises(ValueError) as excinfo:
        parse_int_safely(None)
    # Check that the error message is correct
    assert "Cannot parse None to int" in str(excinfo.value)
    print(f"Caught expected error: {excinfo.value}")

def test_parse_int_invalid() -> None:
    """Test that passing invalid values raises the correct exception."""
    invalid_values = ["not a number", {"a": 1}, [1, 2, 3]]

    for val in invalid_values:
        print(f"Testing that parse_int_safely('{val}') raises ValueError")
        with pytest.raises(ValueError) as excinfo:
            parse_int_safely(val)
        # Verify the error message contains the value
        assert str(val) in str(excinfo.value)
        print(f"Caught expected error: {excinfo.value}")

if __name__ == "__main__":
    test_parse_int_valid()
    test_parse_int_none()
    test_parse_int_invalid()
    print("All exception tests passed!")

    # Valid integer parsing works!
    # Testing that parse_int_safely(None) raises ValueError
    # Caught expected error: Cannot parse None to int
    # Testing that parse_int_safely('not a number') raises ValueError
    # Caught expected error: Cannot parse 'not a number' to int
    # Testing that parse_int_safely('{'a': 1}') raises ValueError
    # Caught expected error: Cannot parse '{'a': 1}' to int
    # Testing that parse_int_safely('[1, 2, 3]') raises ValueError
    # Caught expected error: Cannot parse '[1, 2, 3]' to int
    # All exception tests passed!

# Save as test_fixtures.py
from typing import Dict, List, Any
import pytest

@pytest.fixture
def sample_data() -> List[Dict[str, Any]]:
    """Fixture providing sample customer data for tests."""
    return [
        {"id": 1, "name": "Alice", "age": 30, "purchases": 150},
        {"id": 2, "name": "Bob", "age": 25, "purchases": 200},
        {"id": 3, "name": "Charlie", "age": 35, "purchases": 100},
        {"id": 4, "name": "Diana", "age": 40, "purchases": 300},
        {"id": 5, "name": "Eve", "age": 22, "purchases": 250}
    ]

# Functions to test
def get_customer_by_id(customers: List[Dict[str, Any]], customer_id: int) -> Dict[str, Any]:
    """Find a customer by their ID."""
    for customer in customers:
        if customer["id"] == customer_id:
            return customer
    raise ValueError(f"No customer with ID {customer_id}")

def calculate_total_purchases(customers: List[Dict[str, Any]]) -> float:
    """Calculate the total purchases across all customers."""
    return sum(customer["purchases"] for customer in customers)

def get_customers_by_age_range(customers: List[Dict[str, Any]],
                              min_age: int, max_age: int) -> List[Dict[str, Any]]:
    """Get customers within a specific age range."""
    return [c for c in customers if min_age <= c["age"] <= max_age]

# Tests using the fixture
def test_get_customer_by_id(sample_data: List[Dict[str, Any]]) -> None:
    """Test finding a customer by ID."""
    customer = get_customer_by_id(sample_data, 3)
    print(f"Found customer: {customer}")
    assert customer["name"] == "Charlie"
    assert customer["age"] == 35

def test_calculate_total_purchases(sample_data: List[Dict[str, Any]]) -> None:
    """Test calculating total purchases."""
    total = calculate_total_purchases(sample_data)
    print(f"Total purchases: {total}")
    expected_total = sum(c["purchases"] for c in sample_data)
    assert total == expected_total
    assert total == 1000  # 150 + 200 + 100 + 300 + 250

def test_get_customers_by_age_range(sample_data: List[Dict[str, Any]]) -> None:
    """Test filtering customers by age range."""
    young_customers = get_customers_by_age_range(sample_data, 20, 30)
    print(f"Customers aged 20-30: {[c['name'] for c in young_customers]}")
    assert len(young_customers) == 2
    assert young_customers[0]["name"] == "Bob"
    assert young_customers[1]["name"] == "Eve"

if __name__ == "__main__":
    # For direct execution (not with pytest), create the fixture data manually
    data = sample_data()
    test_get_customer_by_id(data)
    test_calculate_total_purchases(data)
    test_get_customers_by_age_range(data)
    print("All fixture tests passed!")

    # Found customer: {'id': 3, 'name': 'Charlie', 'age': 35, 'purchases': 100}
    # Total purchases: 1000
    # Customers aged 20-30: ['Bob', 'Eve']
    # All fixture tests passed!

# Save as test_fixture_scope.py
from typing import Dict, List, Any, Iterator
import pytest
import os

@pytest.fixture(scope="module")
def temp_data_file() -> Iterator[str]:
    """
    Create a temporary data file for testing.
    This fixture has module scope, so it runs once per test module.
    """
    filename = "temp_test_data.txt"
    print(f"\nCreating temporary file: {filename}")

    # Setup - create the file
    with open(filename, "w") as f:
        f.write("line 1\n")
        f.write("line 2\n")
        f.write("line 3\n")

    # Return the filename to the tests
    yield filename

    # Teardown - clean up after all tests using this fixture are done
    print(f"Cleaning up: Removing {filename}")
    if os.path.exists(filename):
        os.remove(filename)

def count_lines_in_file(filename: str) -> int:
    """Count the number of lines in a file."""
    with open(filename, "r") as f:
        return len(f.readlines())

def append_to_file(filename: str, content: str) -> None:
    """Append content to a file."""
    with open(filename, "a") as f:
        f.write(content)

def test_count_lines(temp_data_file: str) -> None:
    """Test counting lines in the temp file."""
    count = count_lines_in_file(temp_data_file)
    print(f"File has {count} lines")
    assert count == 3

def test_append_to_file(temp_data_file: str) -> None:
    """Test appending to the temp file."""
    original_count = count_lines_in_file(temp_data_file)
    append_to_file(temp_data_file, "line 4\n")
    new_count = count_lines_in_file(temp_data_file)
    print(f"File had {original_count} lines, now has {new_count} lines")
    assert new_count == original_count + 1

if __name__ == "__main__":
    # Manual test execution
    file = temp_data_file.__next__()  # Get the yielded value
    try:
        test_count_lines(file)
        test_append_to_file(file)
        print("All fixture scope tests passed!")
    finally:
        # Execute the teardown code
        try:
            temp_data_file.__next__()
        except StopIteration:
            pass

    # Creating temporary file: temp_test_data.txt
    # File has 3 lines
    # File had 3 lines, now has 4 lines
    # All fixture scope tests passed!
    # Cleaning up: Removing temp_test_data.txt

# Save as test_parametrized.py
from typing import List, Dict, Any, Tuple
import pytest

# Function to test
def get_stats(numbers: List[float]) -> Dict[str, float]:
    """Calculate basic statistics for a list of numbers."""
    if not numbers:
        return {"count": 0, "sum": 0, "avg": 0, "min": 0, "max": 0}
    return {
        "count": len(numbers),
        "sum": sum(numbers),
        "avg": sum(numbers) / len(numbers),
        "min": min(numbers),
        "max": max(numbers)
    }

# Test with parametrization
@pytest.mark.parametrize("test_input,expected", [
    ([1, 2, 3, 4, 5], {"count": 5, "sum": 15, "avg": 3.0, "min": 1, "max": 5}),
    ([10], {"count": 1, "sum": 10, "avg": 10.0, "min": 10, "max": 10}),
    ([], {"count": 0, "sum": 0, "avg": 0, "min": 0, "max": 0})
])
def test_get_stats(test_input: List[float], expected: Dict[str, float]) -> None:
    """Test statistics calculation with different inputs."""
    result = get_stats(test_input)
    print(f"Stats for {test_input}: {result}")
    assert result == expected

if __name__ == "__main__":
    # Test with each set of parameters
    test_cases = [
        ([1, 2, 3, 4, 5], {"count": 5, "sum": 15, "avg": 3.0, "min": 1, "max": 5}),
        ([10], {"count": 1, "sum": 10, "avg": 10.0, "min": 10, "max": 10}),
        ([], {"count": 0, "sum": 0, "avg": 0, "min": 0, "max": 0})
    ]

    for test_input, expected in test_cases:
        test_get_stats(test_input, expected)

    print("All parametrized tests passed!")

    # Stats for [1, 2, 3, 4, 5]: {'count': 5, 'sum': 15, 'avg': 3.0, 'min': 1, 'max': 5}
    # Stats for [10]: {'count': 1, 'sum': 10, 'avg': 10.0, 'min': 10, 'max': 10}
    # Stats for []: {'count': 0, 'sum': 0, 'avg': 0, 'min': 0, 'max': 0}
    # All parametrized tests passed!

# Save as test_factory_fixtures.py
from typing import List, Dict, Any, Callable
import pytest
import random
import string

# Define a factory fixture
@pytest.fixture
def generate_customer_data() -> Callable[[int], List[Dict[str, Any]]]:
    """
    Factory fixture that returns a function to generate customer data.
    This demonstrates how to create parameterized test data.
    """
    def _generate(num_customers: int) -> List[Dict[str, Any]]:
        """Generate a specified number of random customer records."""
        customers = []
        for i in range(1, num_customers + 1):
            # Generate random customer data
            name_length = random.randint(5, 10)
            random_name = ''.join(random.choice(string.ascii_letters)
                                  for _ in range(name_length))

            customers.append({
                "id": i,
                "name": random_name,
                "age": random.randint(18, 70),
                "purchases": random.randint(50, 500)
            })
        return customers

    return _generate

# Function to test
def get_high_value_customers(customers: List[Dict[str, Any]],
                           threshold: float = 200.0) -> List[Dict[str, Any]]:
    """Get customers with purchases above the threshold."""
    return [c for c in customers if c["purchases"] >= threshold]

# Use the factory fixture in tests
def test_high_value_few_customers(generate_customer_data: Callable[[int], List[Dict[str, Any]]]) -> None:
    """Test with a small number of customers."""
    # Generate 5 random customers
    customers = generate_customer_data(5)
    print(f"Generated {len(customers)} random customers")

    # Count how many are high value based on our definition
    high_value_count = sum(1 for c in customers if c["purchases"] >= 200)

    # Test our function
    high_value = get_high_value_customers(customers)
    print(f"Found {len(high_value)} high value customers")

    # Verify the result
    assert len(high_value) == high_value_count
    for customer in high_value:
        assert customer["purchases"] >= 200

def test_high_value_many_customers(generate_customer_data: Callable[[int], List[Dict[str, Any]]]) -> None:
    """Test with a larger number of customers."""
    # Generate 20 random customers
    customers = generate_customer_data(20)
    print(f"Generated {len(customers)} random customers")

    # Count high value customers
    high_value_count = sum(1 for c in customers if c["purchases"] >= 200)

    # Test with different threshold
    threshold = 300
    high_value = get_high_value_customers(customers, threshold)
    high_value_expected = sum(1 for c in customers if c["purchases"] >= threshold)

    print(f"Found {len(high_value)} customers with purchases >= {threshold}")
    assert len(high_value) == high_value_expected

if __name__ == "__main__":
    # For direct execution, simulate fixture behavior
    factory = generate_customer_data()

    # Set random seed for reproducibility in example
    random.seed(42)

    test_high_value_few_customers(factory)
    test_high_value_many_customers(factory)
    print("All factory fixture tests passed!")

    # Generated 5 random customers
    # Found 3 high value customers
    # Generated 20 random customers
    # Found 3 customers with purchases >= 300
    # All factory fixture tests passed!

# Save as data_loader.py
from typing import Dict, List, Any, Optional
import os
import csv
import json
import requests

def load_from_csv(filename: str) -> List[Dict[str, Any]]:
    """Load data from a CSV file."""
    if not os.path.exists(filename):
        raise FileNotFoundError(f"File not found: {filename}")

    with open(filename, 'r', newline='') as f:
        reader = csv.DictReader(f)
        return list(reader)

def load_from_api(url: str, api_key: Optional[str] = None) -> Dict[str, Any]:
    """Load data from an API endpoint."""
    headers = {}
    if api_key:
        headers["Authorization"] = f"Bearer {api_key}"

    response = requests.get(url, headers=headers)
    response.raise_for_status()  # Raise exception for HTTP errors
    return response.json()

def save_to_json(data: Dict[str, Any], filename: str) -> None:
    """Save data to a JSON file."""
    with open(filename, 'w') as f:
        json.dump(data, f, indent=2)

def process_customer_data(source_type: str, source: str) -> Dict[str, Any]:
    """
    Process customer data from either CSV file or API.
    Returns summary statistics.
    """
    customers = []

    if source_type == "csv":
        customers = load_from_csv(source)
    elif source_type == "api":
        api_data = load_from_api(source)
        customers = api_data.get("customers", [])
    else:
        raise ValueError(f"Unsupported source type: {source_type}")

    # Process the data
    total_customers = len(customers)
    if total_customers == 0:
        return {"total": 0, "avg_age": 0, "avg_purchases": 0}

    # Extract and convert numeric fields
    ages = []
    purchases = []

    for customer in customers:
        try:
            age = float(customer.get("age", 0))
            purchase = float(customer.get("purchases", 0))
            ages.append(age)
            purchases.append(purchase)
        except (ValueError, TypeError):
            # Skip records with invalid numeric data
            pass

    # Calculate statistics
    avg_age = sum(ages) / len(ages) if ages else 0
    avg_purchases = sum(purchases) / len(purchases) if purchases else 0

    return {
        "total": total_customers,
        "avg_age": avg_age,
        "avg_purchases": avg_purchases
    }

# Example usage (commented out to avoid actual execution)
# if __name__ == "__main__":
#     # This would actually try to access external resources
#     result = process_customer_data("csv", "customers.csv")
#     print(result)
#
#     result = process_customer_data("api", "https://api.example.com/customers")
#     print(result)

# Save as test_data_loader.py
from typing import Dict, List, Any, Optional, Callable
import pytest
from unittest.mock import patch, mock_open, MagicMock
import json
import data_loader

def test_process_customer_data_csv(monkeypatch: pytest.MonkeyPatch) -> None:
    """Test processing CSV data with mocked file."""
    # Create mock CSV data
    mock_csv_data = [
        {"name": "Alice", "age": "30", "purchases": "150"},
        {"name": "Bob", "age": "25", "purchases": "200"},
        {"name": "Charlie", "age": "35", "purchases": "100"}
    ]

    # Mock the load_from_csv function
    def mock_load_from_csv(filename: str) -> List[Dict[str, Any]]:
        print(f"Mocked load_from_csv called with {filename}")
        return mock_csv_data

    # Apply the mock
    monkeypatch.setattr(data_loader, "load_from_csv", mock_load_from_csv)

    # Call the function we're testing
    result = data_loader.process_customer_data("csv", "fake_file.csv")

    print(f"Process result: {result}")

    # Verify results
    assert result["total"] == 3
    assert result["avg_age"] == (30 + 25 + 35) / 3
    assert result["avg_purchases"] == (150 + 200 + 100) / 3

def test_process_customer_data_api(monkeypatch: pytest.MonkeyPatch) -> None:
    """Test processing API data with mocked requests."""
    # Create mock API response
    mock_api_data = {
        "customers": [
            {"name": "Diana", "age": "40", "purchases": "300"},
            {"name": "Eve", "age": "22", "purchases": "250"}
        ]
    }

    # Mock the load_from_api function
    def mock_load_from_api(url: str, api_key: Optional[str] = None) -> Dict[str, Any]:
        print(f"Mocked load_from_api called with {url}")
        return mock_api_data

    # Apply the mock
    monkeypatch.setattr(data_loader, "load_from_api", mock_load_from_api)

    # Call the function we're testing
    result = data_loader.process_customer_data("api", "https://fake-api.example.com")

    print(f"Process result: {result}")

    # Verify results
    assert result["total"] == 2
    assert result["avg_age"] == (40 + 22) / 2
    assert result["avg_purchases"] == (300 + 250) / 2

def test_invalid_source_type() -> None:
    """Test that an invalid source type raises ValueError."""
    with pytest.raises(ValueError) as excinfo:
        data_loader.process_customer_data("invalid_type", "some_source")

    print(f"Caught expected error: {excinfo.value}")
    assert "Unsupported source type" in str(excinfo.value)

if __name__ == "__main__":
    # Run tests manually
    test_process_customer_data_csv(pytest.MonkeyPatch())
    test_process_customer_data_api(pytest.MonkeyPatch())
    test_invalid_source_type()
    print("All mock tests passed!")

    # Mocked load_from_csv called with fake_file.csv
    # Process result: {'total': 3, 'avg_age': 30.0, 'avg_purchases': 150.0}
    # Mocked load_from_api called with https://fake-api.example.com
    # Process result: {'total': 2, 'avg_age': 31.0, 'avg_purchases': 275.0}
    # Caught expected error: Unsupported source type: invalid_type
    # All mock tests passed!

# Save as test_patch_decorator.py
from typing import Dict, List, Any, Optional, Callable
import pytest
from unittest.mock import patch, MagicMock
import requests
import data_loader

from typing import Dict, List, Union, Optional, TypeVar, Callable, Protocol, cast
import pytest
from unittest.mock import patch, MagicMock
import requests
import data_loader

# Define a protocol for the mock_load_csv parameter instead of using Any
# A Protocol defines an interface that the mock will satisfy at runtime
class CSVLoaderProtocol(Protocol):
    """Protocol defining the interface for the CSV loader function mock."""
    def __call__(self, filename: str) -> List[Dict[str, str]]: ...
    def assert_called_once_with(self, filename: str) -> None: ...

@patch('data_loader.load_from_csv')
def test_csv_with_patch_decorator(mock_load_csv: CSVLoaderProtocol) -> None:
    """Test using the patch decorator to mock CSV loading."""
    # Configure the mock
    # We use MagicMock at runtime, but typehint with our Protocol
    mock_load_csv.return_value = [  # type: ignore
        {"name": "Alice", "age": "30", "purchases": "150"},
        {"name": "Bob", "age": "25", "purchases": "200"}
    ]

    # Call the function under test
    result = data_loader.process_customer_data("csv", "test.csv")

    # Verify the mock was called with the right arguments
    mock_load_csv.assert_called_once_with("test.csv")
    print(f"Mock called with: {mock_load_csv.call_args}")

    # Check the result
    print(f"Process result: {result}")
    assert result["total"] == 2
    assert result["avg_age"] == 27.5  # (30 + 25) / 2
    assert result["avg_purchases"] == 175.0  # (150 + 200) / 2

# Response protocol for mocking HTTP responses
class HTTPResponseProtocol(Protocol):
    """Protocol defining the interface for HTTP response mocks."""
    def json(self) -> Dict[str, Union[List[Dict[str, str]], str, int]]: ...
    def raise_for_status(self) -> None: ...

# Requests get function protocol
class RequestsGetProtocol(Protocol):
    """Protocol defining the interface for requests.get mock."""
    def __call__(self, url: str, headers: Dict[str, str]) -> HTTPResponseProtocol: ...
    def assert_called_once_with(self, url: str, headers: Dict[str, str]) -> None: ...

@patch('requests.get')
def test_api_with_patch_decorator(mock_get: RequestsGetProtocol) -> None:
    """Test using the patch decorator to mock requests.get."""
    # Configure the mock response
    mock_response = MagicMock()
    mock_response.json.return_value = {
        "customers": [
            {"name": "Charlie", "age": "35", "purchases": "100"}
        ]
    }
    mock_response.raise_for_status = MagicMock()  # No-op mock
    mock_get.return_value = mock_response  # type: ignore

    # Call the function under test
    result = data_loader.load_from_api("https://api.example.com")

    # Verify the mock was called correctly
    mock_get.assert_called_once_with("https://api.example.com", headers={})
    print(f"Mock called with: {mock_get.call_args}")

    # Check the result
    print(f"API result: {result}")
    assert "customers" in result
    assert len(result["customers"]) == 1
    assert result["customers"][0]["name"] == "Charlie"

if __name__ == "__main__":
    # For direct execution, use dummy MagicMock objects
    test_csv_with_patch_decorator(MagicMock())
    test_api_with_patch_decorator(MagicMock())
    print("All patch decorator tests passed!")

    # Mock called with: call('test.csv')
    # Process result: {'total': 2, 'avg_age': 27.5, 'avg_purchases': 175.0}
    # Mock called with: call('https://api.example.com', headers={})
    # API result: {'customers': [{'name': 'Charlie', 'age': '35', 'purchases': '100'}]}
    # All patch decorator tests passed!

# Save as test_mock_files.py
from typing import Dict, List, Any, Optional, Callable
import pytest
from unittest.mock import patch, mock_open
import json
import data_loader

@patch('builtins.open', new_callable=mock_open, read_data='name,age,purchases\nAlice,30,150\nBob,25,200')
def test_load_from_csv_with_mock_open(mock_file: Any) -> None:
    """Test loading CSV using mock_open."""
    # Call the function under test
    result = data_loader.load_from_csv("fake.csv")

    # Verify the mock was called correctly
    mock_file.assert_called_once_with('fake.csv', 'r', newline='')
    print(f"Mock file opened with: {mock_file.call_args}")

    # Check the result
    print(f"CSV result: {result}")
    assert len(result) == 2
    assert result[0]['name'] == 'Alice'
    assert result[1]['name'] == 'Bob'

@patch('json.dump')
@patch('builtins.open', new_callable=mock_open)
def test_save_to_json(mock_file: Any, mock_json_dump: Any) -> None:
    """Test saving to JSON using mock_open and mocked json.dump."""
    # Data to save
    test_data = {"key": "value", "numbers": [1, 2, 3]}

    # Call the function under test
    data_loader.save_to_json(test_data, "output.json")

    # Verify the mock was called correctly
    mock_file.assert_called_once_with('output.json', 'w')
    mock_json_dump.assert_called_once()

    # Get the arguments passed to json.dump
    args, kwargs = mock_json_dump.call_args
    print(f"json.dump called with data: {args[0]}")
    print(f"json.dump called with file: {args[1]}")
    print(f"json.dump called with kwargs: {kwargs}")

    # Check that the right data was passed
    assert args[0] == test_data
    assert 'indent' in kwargs
    assert kwargs['indent'] == 2

if __name__ == "__main__":
    # For direct execution
    test_load_from_csv_with_mock_open(mock_open(read_data='name,age,purchases\nAlice,30,150\nBob,25,200'))
    test_save_to_json(mock_open(), lambda *args, **kwargs: None)
    print("All file mock tests passed!")

    # Mock file opened with: call('fake.csv', 'r', newline='')
    # CSV result: [{'name': 'Alice', 'age': '30', 'purchases': '150'}, {'name': 'Bob', 'age': '25', 'purchases': '200'}]
    # json.dump called with data: {'key': 'value', 'numbers': [1, 2, 3]}
    # json.dump called with file: <MagicMock name='open()' id='...'>
    # json.dump called with kwargs: {'indent': 2}
    # All file mock tests passed!

# Save as test_numerical_accuracy.py
from typing import Dict, List, Union, Optional, Tuple, TypeVar, cast
import pytest
import math

def calculate_statistics(values: List[float]) -> Dict[str, float]:
    """Calculate statistics for a list of values."""
    n = len(values)
    if n == 0:
        return {"mean": 0.0, "std_dev": 0.0, "median": 0.0}

    # Calculate mean
    mean = sum(values) / n

    # Calculate standard deviation
    variance = sum((x - mean) ** 2 for x in values) / n
    std_dev = math.sqrt(variance)

    # Calculate median
    sorted_values = sorted(values)
    if n % 2 == 0:
        # Even number of values
        median = (sorted_values[n//2 - 1] + sorted_values[n//2]) / 2
    else:
        # Odd number of values
        median = sorted_values[n//2]

    return {"mean": mean, "std_dev": std_dev, "median": median}

def test_statistics_exact_comparison() -> None:
    """
    Test statistics calculation with exact comparisons.
    This might fail due to floating-point precision issues.
    """
    values = [1.0, 2.0, 3.0, 4.0, 5.0]
    result = calculate_statistics(values)

    print(f"Statistics for {values}: {result}")

    # These exact comparisons might be risky for floating-point values
    # Mean is an exact integer here, so direct comparison works
    expected_mean = 3.0
    expected_std_dev = math.sqrt(2.0)  # This will be an irrational number
    expected_median = 3.0  # Also exact in this case

    assert result["mean"] == expected_mean
    # This might fail due to floating-point precision, so we don't assert it directly:
    # assert result["std_dev"] == expected_std_dev
    assert result["median"] == expected_median

def test_statistics_approx_comparison() -> None:
    """
    Test statistics calculation with approximate comparisons.
    pytest.approx is needed whenever comparing floating-point values
    to avoid precision errors.
    """
    values = [1.0, 2.0, 3.0, 4.0, 5.0]
    result = calculate_statistics(values)

    print(f"Statistics for {values}: {result}")

    # Better approach using pytest.approx for floating-point comparison
    expected_mean = 3.0
    expected_std_dev = math.sqrt(2.0)  # approximately 1.414
    expected_median = 3.0

    # pytest.approx allows for small floating-point differences
    assert result["mean"] == pytest.approx(expected_mean)
    assert result["std_dev"] == pytest.approx(expected_std_dev)
    assert result["median"] == pytest.approx(expected_median)

    # You can also specify tolerance explicitly when needed
    assert result["std_dev"] == pytest.approx(1.414, abs=1e-3)

    print(f"Expected std_dev: {expected_std_dev}, actual: {result['std_dev']}")
    print(f"Difference: {abs(expected_std_dev - result['std_dev'])}")

if __name__ == "__main__":
    test_statistics_exact_comparison()
    test_statistics_approx_comparison()
    print("All numerical tests passed!")

    # Statistics for [1.0, 2.0, 3.0, 4.0, 5.0]: {'mean': 3.0, 'std_dev': 1.4142135623730951, 'median': 3.0}
    # Statistics for [1.0, 2.0, 3.0, 4.0, 5.0]: {'mean': 3.0, 'std_dev': 1.4142135623730951, 'median': 3.0}
    # Expected std_dev: 1.4142135623730951, actual: 1.4142135623730951
    # Difference: 0.0
    # All numerical tests passed!