pdca-code-generation-process

```python
import unittest
from typing import List

# Plan: Implement a function to filter even numbers from a list while handling edge cases like empty lists and non-integer values.
# Do: Initial implementation with basic test coverage
def filter_even_numbers(numbers: List[int]) -> List[int]:
    """Filters even numbers from a list.
    
    Args:
        numbers: List of integers to filter
        
    Returns:
        List containing only even numbers
    """
    return [n for n in numbers if n % 2 == 0]

# Check: Run initial tests
class TestFilterEvenNumbers(unittest.TestCase):
    def test_basic_case(self):
        self.assertEqual(filter_even_numbers([1, 2, 3, 4]), [2, 4])
    
    def test_empty_list(self):
        self.assertEqual(filter_even_numbers([]), [])
    
    def test_no_evens(self):
        self.assertEqual(filter_even_numbers([1, 3, 5]), [])
    
    def test_non_integer_input(self):
        with self.assertRaises(TypeError):
            filter_even_numbers([1, 'a', 3])

if __name__ == '__main__':
    unittest.main()

# Act: Refactor to handle edge cases better and add type checking
from typing import Union, List

def filter_even_numbers(numbers: List[Union[int, float]]) -> List[int]:
    """Filters even numbers from a list with improved type handling.
    
    Args:
        numbers: List of numbers to filter
        
    Returns:
        List containing only even integers
    
    Raises:
        TypeError: If input contains non-numeric values
    """
    if not all(isinstance(n, (int, float)) for n in numbers):
        raise TypeError("All elements must be numeric")
    return [int(n) for n in numbers if n % 2 == 0]

# Plan-Do-Check-Act Cycle Summary:
# Plan: Implement robust even number filtering with type safety
# Do: Added type checking and conversion to integers
# Check: All tests pass including edge cases
# Act: Improved error handling and documentation
```