KitchenSink.py

#!/usr/bin/env python3
"""
KitchenSink.py - A comprehensive Python example file
Demonstrates virtually every Python feature and construct
"""

# ===========================
# 1. IMPORTS AND MODULES
# ===========================
import sys
import os
import json
import re
import time
import datetime
import math
import random
import collections
import itertools
import functools
import typing
from typing import List, Dict, Tuple, Optional, Union, Any, TypeVar, Generic
from dataclasses import dataclass, field
from enum import Enum, auto
from pathlib import Path
import asyncio
import threading
import multiprocessing
from contextlib import contextmanager, suppress
from abc import ABC, abstractmethod
import warnings
import logging

# ===========================
# 2. BASIC DATA TYPES
# ===========================
integer_example = 42
float_example = 3.14159
complex_example = 3 + 4j
boolean_true = True
boolean_false = False
none_example = None
string_example = "Hello, World!"
multiline_string = """This is a
multiline string
example"""
raw_string = r"Raw string with \n no escapes"
f_string = f"Formatted string with {integer_example}"
bytes_example = b"bytes"
bytearray_example = bytearray(b"mutable bytes")

# ===========================
# 3. COLLECTIONS
# ===========================
list_example = [1, 2, 3, 4, 5]
tuple_example = (1, 2, 3)
set_example = {1, 2, 3, 4, 5}
frozenset_example = frozenset({1, 2, 3})
dict_example = {"key1": "value1", "key2": "value2"}
defaultdict_example = collections.defaultdict(list)
counter_example = collections.Counter(['a', 'b', 'c', 'a', 'b', 'b'])
deque_example = collections.deque([1, 2, 3])
namedtuple_example = collections.namedtuple('Point', ['x', 'y'])
OrderedDict_example = collections.OrderedDict()

# ===========================
# 4. OPERATORS
# ===========================
arithmetic = 10 + 5 - 3 * 2 / 2 ** 2 // 2 % 3
comparison = 5 > 3 < 10 >= 5 <= 10 == 10 != 5
logical = True and False or not False
bitwise = 5 & 3 | 2 ^ 1 << 2 >> 1 ~ 5
identity = None is None
membership = 3 in [1, 2, 3]
assignment = (x := 10)  # Walrus operator

# ===========================
# 5. CONTROL FLOW
# ===========================
def control_flow_examples():
    # If-elif-else
    x = 10
    if x > 10:
        result = "greater"
    elif x < 10:
        result = "less"
    else:
        result = "equal"
    
    # Ternary operator
    result = "positive" if x > 0 else "non-positive"
    
    # For loops
    for i in range(5):
        pass
    
    for index, value in enumerate([1, 2, 3]):
        pass
    
    for key, value in dict_example.items():
        pass
    
    # While loop
    counter = 0
    while counter < 5:
        counter += 1
    
    # Break and continue
    for i in range(10):
        if i == 3:
            continue
        if i == 7:
            break
    
    # Else clause in loops
    for i in range(3):
        pass
    else:
        pass  # Executed if loop completes without break
    
    # Match statement (Python 3.10+)
    match x:
        case 0:
            result = "zero"
        case 1 | 2 | 3:
            result = "small"
        case _:
            result = "other"

# ===========================
# 6. FUNCTIONS
# ===========================
def basic_function():
    """Docstring for the function"""
    return "result"

def function_with_args(positional, *args, keyword="default", **kwargs):
    """Function with various argument types"""
    return positional, args, keyword, kwargs

def function_with_type_hints(x: int, y: str) -> Tuple[int, str]:
    """Function with type hints"""
    return x, y

# Lambda functions
lambda_func = lambda x: x ** 2
lambda_multiple = lambda x, y: x + y

# Nested functions and closures
def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

# Decorators
def decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@decorator
def decorated_function():
    return "decorated"

# Generator function
def generator_function():
    yield 1
    yield 2
    yield 3

# Async function
async def async_function():
    await asyncio.sleep(0.1)
    return "async result"

# ===========================
# 7. CLASSES AND OOP
# ===========================
class BasicClass:
    """Basic class example"""
    class_variable = "shared"
    
    def __init__(self, value):
        self.instance_variable = value
    
    def instance_method(self):
        return self.instance_variable
    
    @classmethod
    def class_method(cls):
        return cls.class_variable
    
    @staticmethod
    def static_method():
        return "static"
    
    @property
    def property_example(self):
        return self._property_value
    
    @property_example.setter
    def property_example(self, value):
        self._property_value = value

# Inheritance
class ParentClass:
    def parent_method(self):
        return "parent"

class ChildClass(ParentClass):
    def __init__(self):
        super().__init__()
    
    def child_method(self):
        return "child"

# Multiple inheritance
class Mixin1:
    def mixin1_method(self):
        return "mixin1"

class Mixin2:
    def mixin2_method(self):
        return "mixin2"

class MultipleInheritance(Mixin1, Mixin2):
    pass

# Abstract base class
class AbstractClass(ABC):
    @abstractmethod
    def abstract_method(self):
        pass

# Dataclass
@dataclass
class DataClassExample:
    name: str
    value: int = 0
    items: List[str] = field(default_factory=list)

# Enum
class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = auto()

# Metaclass
class MetaClass(type):
    def __new__(mcs, name, bases, namespace):
        return super().__new__(mcs, name, bases, namespace)

class ClassWithMetaclass(metaclass=MetaClass):
    pass

# ===========================
# 8. MAGIC METHODS
# ===========================
class MagicMethods:
    def __init__(self, value):
        self.value = value
    
    def __str__(self):
        return f"MagicMethods({self.value})"
    
    def __repr__(self):
        return f"MagicMethods(value={self.value!r})"
    
    def __len__(self):
        return len(str(self.value))
    
    def __getitem__(self, key):
        return self.value[key]
    
    def __setitem__(self, key, value):
        self.value[key] = value
    
    def __delitem__(self, key):
        del self.value[key]
    
    def __iter__(self):
        return iter(self.value)
    
    def __contains__(self, item):
        return item in self.value
    
    def __call__(self, *args, **kwargs):
        return self.value(*args, **kwargs)
    
    def __enter__(self):
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        pass
    
    def __add__(self, other):
        return MagicMethods(self.value + other.value)
    
    def __eq__(self, other):
        return self.value == other.value
    
    def __lt__(self, other):
        return self.value < other.value
    
    def __hash__(self):
        return hash(self.value)
    
    def __bool__(self):
        return bool(self.value)
    
    def __getattr__(self, name):
        return getattr(self.value, name)
    
    def __setattr__(self, name, value):
        super().__setattr__(name, value)
    
    def __delattr__(self, name):
        super().__delattr__(name)

# ===========================
# 9. COMPREHENSIONS
# ===========================
list_comp = [x ** 2 for x in range(10)]
list_comp_filtered = [x for x in range(10) if x % 2 == 0]
set_comp = {x for x in range(10)}
dict_comp = {x: x ** 2 for x in range(5)}
generator_exp = (x ** 2 for x in range(10))
nested_comp = [[x * y for x in range(3)] for y in range(3)]

# ===========================
# 10. EXCEPTION HANDLING
# ===========================
def exception_handling():
    try:
        result = 10 / 0
    except ZeroDivisionError as e:
        print(f"Caught: {e}")
    except (ValueError, TypeError) as e:
        print(f"Multiple exceptions: {e}")
    except Exception as e:
        print(f"General exception: {e}")
    else:
        print("No exception occurred")
    finally:
        print("Always executed")
    
    # Raising exceptions
    raise ValueError("Custom error message")
    
    # Custom exception
    class CustomException(Exception):
        pass
    
    # Exception chaining
    try:
        raise ValueError("Original")
    except ValueError as e:
        raise RuntimeError("New error") from e

# ===========================
# 11. CONTEXT MANAGERS
# ===========================
@contextmanager
def custom_context_manager():
    print("Entering context")
    try:
        yield "context value"
    finally:
        print("Exiting context")

def context_manager_usage():
    with custom_context_manager() as value:
        print(value)
    
    with suppress(ValueError):
        int("not a number")
    
    with open("file.txt", "w") as f:
        f.write("content")

# ===========================
# 12. ITERATORS AND GENERATORS
# ===========================
class CustomIterator:
    def __init__(self, limit):
        self.limit = limit
        self.counter = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.counter < self.limit:
            self.counter += 1
            return self.counter
        raise StopIteration

def generator_examples():
    # Generator function
    def simple_generator():
        yield 1
        yield 2
        yield 3
    
    # Generator expression
    gen_exp = (x ** 2 for x in range(10))
    
    # Send values to generator
    def generator_with_send():
        value = yield
        while True:
            value = yield value ** 2
    
    gen = generator_with_send()
    next(gen)  # Prime the generator
    result = gen.send(5)
    
    # yield from
    def delegating_generator():
        yield from range(5)
        yield from "abc"

# ===========================
# 13. DECORATORS
# ===========================
def timing_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} took {end - start} seconds")
        return result
    return wrapper

def decorator_with_args(prefix=""):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print(f"{prefix}: Calling {func.__name__}")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@timing_decorator
@decorator_with_args("LOG")
def decorated_function():
    time.sleep(0.1)
    return "result"

# Class decorator
def class_decorator(cls):
    cls.decorated = True
    return cls

@class_decorator
class DecoratedClass:
    pass

# ===========================
# 14. FUNCTIONAL PROGRAMMING
# ===========================
def functional_examples():
    # Map, filter, reduce
    mapped = list(map(lambda x: x ** 2, [1, 2, 3]))
    filtered = list(filter(lambda x: x > 2, [1, 2, 3, 4]))
    reduced = functools.reduce(lambda x, y: x + y, [1, 2, 3, 4])
    
    # Partial functions
    add_five = functools.partial(lambda x, y: x + y, 5)
    result = add_five(3)
    
    # Function composition
    compose = lambda f, g: lambda x: f(g(x))
    add_one = lambda x: x + 1
    double = lambda x: x * 2
    add_one_and_double = compose(double, add_one)
    
    # Higher-order functions
    def apply_twice(func, arg):
        return func(func(arg))
    
    # Currying
    def curry(func):
        def curried(*args, **kwargs):
            if len(args) + len(kwargs) >= func.__code__.co_argcount:
                return func(*args, **kwargs)
            return lambda *args2, **kwargs2: curried(*(args + args2), **{**kwargs, **kwargs2})
        return curried

# ===========================
# 15. TYPING AND TYPE HINTS
# ===========================
from typing import (
    List, Dict, Tuple, Set, Optional, Union, Any, 
    Callable, TypeVar, Generic, Protocol, Literal,
    Final, TypedDict, NewType, cast, overload
)

T = TypeVar('T')
K = TypeVar('K')
V = TypeVar('V')

class GenericClass(Generic[T]):
    def __init__(self, value: T):
        self.value: T = value
    
    def get_value(self) -> T:
        return self.value

def typed_function(
    required: str,
    optional: Optional[int] = None,
    union_type: Union[str, int] = "",
    list_type: List[int] = [],
    dict_type: Dict[str, Any] = {},
    tuple_type: Tuple[int, str, float] = (0, "", 0.0),
    callable_type: Callable[[int], str] = str,
) -> Dict[str, Any]:
    return locals()

class TypedProtocol(Protocol):
    def method(self) -> str:
        ...

class TypedDict(TypedDict):
    name: str
    age: int
    optional_field: Optional[str]

UserId = NewType('UserId', int)
user_id: UserId = UserId(42)

@overload
def overloaded_func(x: int) -> int: ...
@overload
def overloaded_func(x: str) -> str: ...
def overloaded_func(x: Union[int, str]) -> Union[int, str]:
    return x

# ===========================
# 16. ASYNC/AWAIT
# ===========================
async def async_examples():
    # Basic async/await
    async def fetch_data():
        await asyncio.sleep(1)
        return "data"
    
    # Async context manager
    class AsyncContextManager:
        async def __aenter__(self):
            await asyncio.sleep(0.1)
            return self
        
        async def __aexit__(self, exc_type, exc_val, exc_tb):
            await asyncio.sleep(0.1)
    
    # Async iterator
    class AsyncIterator:
        def __init__(self):
            self.counter = 0
        
        def __aiter__(self):
            return self
        
        async def __anext__(self):
            if self.counter < 3:
                self.counter += 1
                await asyncio.sleep(0.1)
                return self.counter
            raise StopAsyncIteration
    
    # Async generator
    async def async_generator():
        for i in range(3):
            await asyncio.sleep(0.1)
            yield i
    
    # Async comprehension
    async_comp = [x async for x in async_generator()]
    
    # Gather multiple coroutines
    results = await asyncio.gather(
        fetch_data(),
        fetch_data(),
        fetch_data()
    )
    
    # Create task
    task = asyncio.create_task(fetch_data())
    result = await task

# ===========================
# 17. METACLASSES AND DESCRIPTORS
# ===========================
class Descriptor:
    def __init__(self, name=None):
        self.name = name
    
    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return obj.__dict__.get(self.name)
    
    def __set__(self, obj, value):
        obj.__dict__[self.name] = value
    
    def __delete__(self, obj):
        del obj.__dict__[self.name]

class Singleton(type):
    _instances = {}
    
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class SingletonClass(metaclass=Singleton):
    pass

# ===========================
# 18. MODULES AND PACKAGES
# ===========================
def module_examples():
    # Import statements
    import math
    from math import pi, sqrt
    from math import pi as PI
    import numpy as np  # alias
    
    # Module attributes
    print(__name__)
    print(__file__)
    print(__doc__)
    
    # Dynamic imports
    module_name = "json"
    module = __import__(module_name)
    
    # importlib
    import importlib
    json_module = importlib.import_module('json')
    
    # Reload module
    importlib.reload(json_module)

# ===========================
# 19. FILE I/O
# ===========================
def file_io_examples():
    # Text files
    with open("text.txt", "w") as f:
        f.write("Hello, World!")
    
    with open("text.txt", "r") as f:
        content = f.read()
    
    # Binary files
    with open("binary.bin", "wb") as f:
        f.write(b"Binary data")
    
    with open("binary.bin", "rb") as f:
        binary_content = f.read()
    
    # JSON
    data = {"key": "value"}
    with open("data.json", "w") as f:
        json.dump(data, f)
    
    with open("data.json", "r") as f:
        loaded_data = json.load(f)
    
    # CSV
    import csv
    with open("data.csv", "w", newline='') as f:
        writer = csv.writer(f)
        writer.writerow(["name", "age"])
        writer.writerow(["Alice", 30])
    
    # Path operations
    path = Path("./example.txt")
    path.exists()
    path.is_file()
    path.is_dir()
    path.parent
    path.name
    path.suffix

# ===========================
# 20. REGULAR EXPRESSIONS
# ===========================
def regex_examples():
    pattern = r"\d+"
    text = "There are 123 numbers and 456 more"
    
    # Search
    match = re.search(pattern, text)
    if match:
        print(match.group())
    
    # Find all
    matches = re.findall(pattern, text)
    
    # Split
    parts = re.split(r"\s+", text)
    
    # Replace
    replaced = re.sub(r"\d+", "X", text)
    
    # Compile pattern
    compiled = re.compile(pattern)
    compiled.findall(text)
    
    # Groups
    pattern_with_groups = r"(\w+)@(\w+)\.(\w+)"
    email = "user@example.com"
    match = re.match(pattern_with_groups, email)
    if match:
        username, domain, tld = match.groups()

# ===========================
# 21. THREADING AND MULTIPROCESSING
# ===========================
def threading_examples():
    # Threading
    def worker(name):
        print(f"Worker {name} starting")
        time.sleep(1)
        print(f"Worker {name} done")
    
    threads = []
    for i in range(3):
        t = threading.Thread(target=worker, args=(i,))
        threads.append(t)
        t.start()
    
    for t in threads:
        t.join()
    
    # Lock
    lock = threading.Lock()
    with lock:
        pass  # Critical section
    
    # Multiprocessing
    def process_worker(name):
        print(f"Process {name} starting")
        time.sleep(1)
        return f"Process {name} result"
    
    with multiprocessing.Pool(processes=4) as pool:
        results = pool.map(process_worker, range(4))

# ===========================
# 22. LOGGING
# ===========================
def logging_examples():
    # Configure logging
    logging.basicConfig(
        level=logging.DEBUG,
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    )
    
    logger = logging.getLogger(__name__)
    
    # Log levels
    logger.debug("Debug message")
    logger.info("Info message")
    logger.warning("Warning message")
    logger.error("Error message")
    logger.critical("Critical message")
    
    # Log with exception
    try:
        1 / 0
    except Exception:
        logger.exception("An error occurred")

# ===========================
# 23. TESTING
# ===========================
import unittest
from unittest.mock import Mock, patch, MagicMock

class TestExample(unittest.TestCase):
    def setUp(self):
        self.value = 42
    
    def tearDown(self):
        pass
    
    def test_equality(self):
        self.assertEqual(2 + 2, 4)
    
    def test_truth(self):
        self.assertTrue(True)
        self.assertFalse(False)
    
    def test_membership(self):
        self.assertIn(2, [1, 2, 3])
    
    def test_exception(self):
        with self.assertRaises(ValueError):
            raise ValueError("test")
    
    def test_mock(self):
        mock = Mock(return_value=42)
        self.assertEqual(mock(), 42)
    
    @patch('module.function')
    def test_patch(self, mock_function):
        mock_function.return_value = "mocked"

# ===========================
# 24. PROPERTIES AND SLOTS
# ===========================
class PropertyExample:
    def __init__(self):
        self._value = None
    
    @property
    def value(self):
        return self._value
    
    @value.setter
    def value(self, new_value):
        if new_value < 0:
            raise ValueError("Value must be non-negative")
        self._value = new_value
    
    @value.deleter
    def value(self):
        del self._value

class SlotsExample:
    __slots__ = ['x', 'y']
    
    def __init__(self, x, y):
        self.x = x
        self.y = y

# ===========================
# 25. WEAK REFERENCES
# ===========================
import weakref

class WeakRefExample:
    def __init__(self, value):
        self.value = value

def weakref_examples():
    obj = WeakRefExample(42)
    weak_ref = weakref.ref(obj)
    
    # Access through weak reference
    if weak_ref() is not None:
        print(weak_ref().value)
    
    # WeakValueDictionary
    weak_dict = weakref.WeakValueDictionary()
    weak_dict['key'] = obj

# ===========================
# 26. PICKLE AND SERIALIZATION
# ===========================
import pickle

def pickle_examples():
    # Pickle object
    data = {'key': 'value', 'list': [1, 2, 3]}
    pickled = pickle.dumps(data)
    unpickled = pickle.loads(pickled)
    
    # Pickle to file
    with open('data.pkl', 'wb') as f:
        pickle.dump(data, f)
    
    with open('data.pkl', 'rb') as f:
        loaded = pickle.load(f)

# ===========================
# 27. INTROSPECTION
# ===========================
def introspection_examples():
    obj = BasicClass("test")
    
    # Type checking
    print(type(obj))
    print(isinstance(obj, BasicClass))
    print(issubclass(BasicClass, object))
    
    # Attributes
    print(dir(obj))
    print(vars(obj))
    print(hasattr(obj, 'instance_variable'))
    print(getattr(obj, 'instance_variable', 'default'))
    setattr(obj, 'new_attr', 'value')
    delattr(obj, 'new_attr')
    
    # Callable
    print(callable(obj.instance_method))
    
    # Module and class info
    print(obj.__class__)
    print(obj.__module__)
    print(obj.__dict__)
    
    # Function introspection
    import inspect
    print(inspect.signature(function_with_args))
    print(inspect.getmembers(obj))
    print(inspect.getsource(BasicClass))

# ===========================
# 28. OPERATOR OVERLOADING
# ===========================
class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)
    
    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)
    
    def __truediv__(self, scalar):
        return Vector(self.x / scalar, self.y / scalar)
    
    def __neg__(self):
        return Vector(-self.x, -self.y)
    
    def __abs__(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5
    
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

# ===========================
# 29. NAMESPACE AND SCOPE
# ===========================
global_var = "global"

def scope_examples():
    enclosing_var = "enclosing"
    
    def inner():
        local_var = "local"
        
        # LEGB rule: Local, Enclosing, Global, Built-in
        print(local_var)      # Local
        print(enclosing_var)  # Enclosing
        print(global_var)     # Global
        print(len)            # Built-in
        
        # Modifying outer scope
        nonlocal enclosing_var
        enclosing_var = "modified enclosing"
        
        global global_var
        global_var = "modified global"
    
    inner()

# ===========================
# 30. MEMORY MANAGEMENT
# ===========================
import gc

def memory_management():
    # Garbage collection
    gc.collect()
    gc.get_count()
    gc.get_threshold()
    gc.set_threshold(700, 10, 10)
    
    # Reference counting
    obj = object()
    ref_count = sys.getrefcount(obj)
    
    # Memory usage
    import tracemalloc
    tracemalloc.start()
    
    # ... code to profile ...
    
    current, peak = tracemalloc.get_traced_memory()
    tracemalloc.stop()

# ===========================
# 31. PERFORMANCE OPTIMIZATION
# ===========================
def performance_examples():
    # Timeit
    import timeit
    execution_time = timeit.timeit('sum(range(100))', number=10000)
    
    # Profile
    import cProfile
    cProfile.run('sum(range(1000000))')
    
    # LRU Cache
    @functools.lru_cache(maxsize=128)
    def fibonacci(n):
        if n < 2:
            return n
        return fibonacci(n-1) + fibonacci(n-2)
    
    # Slots for memory optimization
    class OptimizedClass:
        __slots__ = ['x', 'y']
        
        def __init__(self, x, y):
            self.x = x
            self.y = y

# ===========================
# 32. COMMAND LINE ARGUMENTS
# ===========================
import argparse

def argparse_example():
    parser = argparse.ArgumentParser(description='Example CLI')
    parser.add_argument('positional', help='Positional argument')
    parser.add_argument('-o', '--optional', help='Optional argument')
    parser.add_argument('-f', '--flag', action='store_true')
    parser.add_argument('-c', '--count', type=int, default=1)
    parser.add_argument('-m', '--multiple', nargs='+')
    
    # In actual use: args = parser.parse_args()
    # For demo: args = parser.parse_args(['value', '-o', 'opt', '-f'])

# ===========================
# 33. ENVIRONMENT VARIABLES
# ===========================
def environment_examples():
    # Get environment variable
    home = os.environ.get('HOME', 'default')
    path = os.getenv('PATH', '')
    
    # Set environment variable
    os.environ['MY_VAR'] = 'value'
    
    # List all environment variables
    for key, value in os.environ.items():
        pass

# ===========================
# 34. WARNINGS
# ===========================
def warning_examples():
    # Issue warning
    warnings.warn("This is a warning", UserWarning)
    
    # Filter warnings
    warnings.filterwarnings("ignore", category=DeprecationWarning)
    
    # Context manager for warnings
    with warnings.catch_warnings():
        warnings.simplefilter("always")
        warnings.warn("This warning will be shown", RuntimeWarning)
    
    # Custom warning
    class CustomWarning(Warning):
        pass
    
    warnings.warn("Custom warning", CustomWarning)

# ===========================
# 35. ZIP AND ENUMERATE
# ===========================
def zip_enumerate_examples():
    # Zip
    list1 = [1, 2, 3]
    list2 = ['a', 'b', 'c']
    zipped = list(zip(list1, list2))
    
    # Zip with different lengths
    from itertools import zip_longest
    zipped_longest = list(zip_longest(list1, [1, 2], fillvalue=0))
    
    # Unzip
    pairs = [(1, 'a'), (2, 'b'), (3, 'c')]
    numbers, letters = zip(*pairs)
    
    # Enumerate
    for index, value in enumerate(['a', 'b', 'c']):
        print(f"{index}: {value}")
    
    # Enumerate with start
    for index, value in enumerate(['a', 'b', 'c'], start=1):
        print(f"{index}: {value}")

# ===========================
# 36. ITERTOOLS
# ===========================
def itertools_examples():
    import itertools
    
    # Infinite iterators
    counter = itertools.count(start=1, step=2)
    cycler = itertools.cycle([1, 2, 3])
    repeater = itertools.repeat(10, times=3)
    
    # Combinatoric iterators
    perms = list(itertools.permutations([1, 2, 3]))
    combs = list(itertools.combinations([1, 2, 3, 4], 2))
    combs_replace = list(itertools.combinations_with_replacement([1, 2], 2))
    product = list(itertools.product([1, 2], ['a', 'b']))
    
    # Terminating iterators
    accumulated = list(itertools.accumulate([1, 2, 3, 4]))
    chained = list(itertools.chain([1, 2], [3, 4], [5, 6]))
    compressed = list(itertools.compress('ABCDEF', [1, 0, 1, 0, 1, 1]))
    dropped = list(itertools.dropwhile(lambda x: x < 5, [1, 4, 6, 4, 1]))
    filtered = list(itertools.filterfalse(lambda x: x % 2, range(10)))
    grouped = [(k, list(g)) for k, g in itertools.groupby('AAAABBBCCDAABBB')]
    sliced = list(itertools.islice(itertools.count(), 5, 10))
    taken = list(itertools.takewhile(lambda x: x < 5, [1, 4, 6, 4, 1]))
    
    # Tee - create multiple iterators
    iter1, iter2 = itertools.tee([1, 2, 3])

# ===========================
# 37. COLLECTIONS MODULE
# ===========================
def collections_examples():
    from collections import (
        Counter, defaultdict, OrderedDict, deque,
        namedtuple, ChainMap, UserDict, UserList, UserString
    )
    
    # Counter
    counter = Counter('abracadabra')
    counter.most_common(3)
    counter.update('aaa')
    counter.subtract('abc')
    
    # defaultdict
    dd = defaultdict(list)
    dd['key'].append('value')
    
    # OrderedDict (maintains insertion order in Python 3.7+)
    od = OrderedDict()
    od['first'] = 1
    od['second'] = 2
    od.move_to_end('first')
    
    # deque (double-ended queue)
    dq = deque([1, 2, 3], maxlen=5)
    dq.append(4)
    dq.appendleft(0)
    dq.rotate(1)
    dq.pop()
    dq.popleft()
    
    # namedtuple
    Point = namedtuple('Point', ['x', 'y'])
    p = Point(11, y=22)
    x, y = p
    
    # ChainMap
    dict1 = {'a': 1, 'b': 2}
    dict2 = {'b': 3, 'c': 4}
    chain = ChainMap(dict1, dict2)

# ===========================
# 38. STRING METHODS
# ===========================
def string_methods():
    s = "  Hello, World!  "
    
    # Case methods
    s.upper()
    s.lower()
    s.capitalize()
    s.title()
    s.swapcase()
    
    # Search methods
    s.find('World')
    s.index('World')
    s.rfind('o')
    s.rindex('o')
    s.count('l')
    
    # Boolean methods
    s.startswith('Hello')
    s.endswith('!')
    s.isalpha()
    s.isdigit()
    s.isalnum()
    s.isspace()
    s.isupper()
    s.islower()
    
    # Modification methods
    s.strip()
    s.lstrip()
    s.rstrip()
    s.replace('World', 'Python')
    s.split(',')
    '-'.join(['a', 'b', 'c'])
    s.center(30)
    s.ljust(30)
    s.rjust(30)
    s.zfill(30)
    
    # Format methods
    "Hello, {}!".format("World")
    "Hello, {name}!".format(name="World")
    f"Hello, {'World'}!"
    
    # Translation
    trans_table = str.maketrans('aeiou', '12345')
    "hello".translate(trans_table)

# ===========================
# 39. MATH AND NUMBERS
# ===========================
def math_examples():
    import math
    import decimal
    import fractions
    import statistics
    
    # Math functions
    math.ceil(4.3)
    math.floor(4.7)
    math.trunc(4.5)
    math.round(4.5)
    abs(-5)
    
    # Power and logarithms
    math.pow(2, 3)
    math.sqrt(16)
    math.exp(1)
    math.log(10)
    math.log10(100)
    math.log2(8)
    
    # Trigonometry
    math.sin(math.pi / 2)
    math.cos(0)
    math.tan(math.pi / 4)
    math.degrees(math.pi)
    math.radians(180)
    
    # Constants
    math.pi
    math.e
    math.inf
    math.nan
    
    # Decimal for precision
    decimal.Decimal('0.1') + decimal.Decimal('0.2')
    
    # Fractions
    fractions.Fraction(1, 3) + fractions.Fraction(1, 6)
    
    # Statistics
    data = [1, 2, 3, 4, 5]
    statistics.mean(data)
    statistics.median(data)
    statistics.mode([1, 1, 2, 3, 3, 3, 4])
    statistics.stdev(data)
    statistics.variance(data)

# ===========================
# 40. DATE AND TIME
# ===========================
def datetime_examples():
    from datetime import datetime, date, time, timedelta
    import time as time_module
    
    # Current time
    now = datetime.now()
    today = date.today()
    current_time = time(14, 30, 45)
    
    # Create datetime
    dt = datetime(2024, 1, 1, 12, 0, 0)
    
    # Format datetime
    formatted = now.strftime("%Y-%m-%d %H:%M:%S")
    
    # Parse datetime
    parsed = datetime.strptime("2024-01-01", "%Y-%m-%d")
    
    # Timedelta
    tomorrow = today + timedelta(days=1)
    last_week = today - timedelta(weeks=1)
    
    # Time module
    time_module.sleep(0.1)
    timestamp = time_module.time()
    
    # Timezone (Python 3.9+)
    from zoneinfo import ZoneInfo
    utc_time = datetime.now(ZoneInfo('UTC'))
    
    # Calendar
    import calendar
    calendar.isleap(2024)
    calendar.monthrange(2024, 2)

# ===========================
# 41. RANDOM
# ===========================
def random_examples():
    import random
    import secrets
    
    # Random numbers
    random.random()  # 0.0 to 1.0
    random.uniform(1, 10)  # Float in range
    random.randint(1, 10)  # Integer in range
    random.randrange(0, 10, 2)  # Even numbers
    
    # Random choice
    random.choice([1, 2, 3, 4, 5])
    random.choices([1, 2, 3], weights=[1, 2, 3], k=10)
    random.sample([1, 2, 3, 4, 5], k=3)
    
    # Shuffle
    items = [1, 2, 3, 4, 5]
    random.shuffle(items)
    
    # Seed for reproducibility
    random.seed(42)
    
    # Cryptographically secure random
    secrets.token_bytes(16)
    secrets.token_hex(16)
    secrets.token_urlsafe(16)
    secrets.choice([1, 2, 3])

# ===========================
# 42. OS AND SYSTEM
# ===========================
def os_system_examples():
    import os
    import sys
    import platform
    import subprocess
    
    # OS information
    os.name
    platform.system()
    platform.release()
    platform.version()
    platform.machine()
    platform.processor()
    platform.python_version()
    
    # File system
    os.getcwd()
    os.chdir('/tmp')
    os.listdir('.')
    os.mkdir('new_dir')
    os.makedirs('path/to/dir', exist_ok=True)
    os.remove('file.txt')
    os.rmdir('empty_dir')
    os.rename('old.txt', 'new.txt')
    
    # Path operations
    os.path.join('dir', 'file.txt')
    os.path.split('/path/to/file.txt')
    os.path.dirname('/path/to/file.txt')
    os.path.basename('/path/to/file.txt')
    os.path.exists('/path/to/file.txt')
    os.path.isfile('/path/to/file.txt')
    os.path.isdir('/path/to/dir')
    os.path.getsize('/path/to/file.txt')
    
    # System
    sys.argv
    sys.exit(0)
    sys.stdin
    sys.stdout
    sys.stderr
    sys.version
    sys.path
    sys.modules
    
    # Subprocess
    result = subprocess.run(['ls', '-l'], capture_output=True, text=True)
    result.stdout
    result.stderr
    result.returncode

# ===========================
# 43. NETWORKING
# ===========================
def networking_examples():
    import socket
    import urllib.request
    import urllib.parse
    import http.client
    
    # Socket
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect(('example.com', 80))
    sock.send(b'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
    response = sock.recv(1024)
    sock.close()
    
    # URL operations
    url = 'https://example.com/path?param=value'
    parsed = urllib.parse.urlparse(url)
    query_params = urllib.parse.parse_qs(parsed.query)
    encoded = urllib.parse.quote('special characters!')
    
    # HTTP request
    with urllib.request.urlopen('https://api.example.com/data') as response:
        data = response.read()
    
    # HTTP client
    conn = http.client.HTTPSConnection("api.example.com")
    conn.request("GET", "/data")
    response = conn.getresponse()
    data = response.read()
    conn.close()

# ===========================
# 44. DATABASE
# ===========================
def database_examples():
    import sqlite3
    
    # Connect to database
    conn = sqlite3.connect(':memory:')  # In-memory database
    cursor = conn.cursor()
    
    # Create table
    cursor.execute('''
        CREATE TABLE users (
            id INTEGER PRIMARY KEY,
            name TEXT NOT NULL,
            email TEXT UNIQUE
        )
    ''')
    
    # Insert data
    cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", 
                   ("Alice", "alice@example.com"))
    
    # Insert many
    users = [("Bob", "bob@example.com"), ("Charlie", "charlie@example.com")]
    cursor.executemany("INSERT INTO users (name, email) VALUES (?, ?)", users)
    
    # Query data
    cursor.execute("SELECT * FROM users WHERE name = ?", ("Alice",))
    row = cursor.fetchone()
    
    cursor.execute("SELECT * FROM users")
    rows = cursor.fetchall()
    
    # Update data
    cursor.execute("UPDATE users SET email = ? WHERE name = ?", 
                   ("newemail@example.com", "Alice"))
    
    # Delete data
    cursor.execute("DELETE FROM users WHERE name = ?", ("Bob",))
    
    # Commit and close
    conn.commit()
    conn.close()

# ===========================
# 45. UNIT TESTING WITH PYTEST
# ===========================
"""
# pytest examples (requires pytest installation)
import pytest

def test_addition():
    assert 2 + 2 == 4

def test_exception():
    with pytest.raises(ValueError):
        raise ValueError("test")

@pytest.fixture
def sample_data():
    return [1, 2, 3, 4, 5]

def test_with_fixture(sample_data):
    assert len(sample_data) == 5

@pytest.mark.parametrize("input,expected", [
    (2, 4),
    (3, 9),
    (4, 16),
])
def test_square(input, expected):
    assert input ** 2 == expected

@pytest.mark.skip(reason="Not implemented yet")
def test_future_feature():
    pass

@pytest.mark.skipif(sys.version_info < (3, 10), reason="Requires Python 3.10+")
def test_new_feature():
    pass
"""

# ===========================
# 46. DESIGN PATTERNS
# ===========================

# Singleton Pattern
class SingletonPattern:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

# Factory Pattern
class AnimalFactory:
    @staticmethod
    def create_animal(animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        else:
            raise ValueError(f"Unknown animal type: {animal_type}")

class Dog:
    def speak(self):
        return "Woof!"

class Cat:
    def speak(self):
        return "Meow!"

# Observer Pattern
class Subject:
    def __init__(self):
        self._observers = []
    
    def attach(self, observer):
        self._observers.append(observer)
    
    def notify(self, message):
        for observer in self._observers:
            observer.update(message)

class Observer:
    def update(self, message):
        print(f"Received: {message}")

# Decorator Pattern (not Python decorator)
class Coffee:
    def cost(self):
        return 5

class MilkDecorator:
    def __init__(self, coffee):
        self._coffee = coffee
    
    def cost(self):
        return self._coffee.cost() + 2

# Strategy Pattern
class Strategy(ABC):
    @abstractmethod
    def execute(self, data):
        pass

class ConcreteStrategyA(Strategy):
    def execute(self, data):
        return sorted(data)

class ConcreteStrategyB(Strategy):
    def execute(self, data):
        return reversed(data)

class Context:
    def __init__(self, strategy):
        self._strategy = strategy
    
    def execute_strategy(self, data):
        return self._strategy.execute(data)

# ===========================
# 47. ADVANCED FEATURES
# ===========================

# Structural Pattern Matching (Python 3.10+)
def pattern_matching_example(value):
    match value:
        case 0:
            return "zero"
        case [x, y]:
            return f"list with {x} and {y}"
        case {"name": name, "age": age}:
            return f"{name} is {age} years old"
        case _:
            return "something else"

# Union types (Python 3.10+)
def process_value(value: int | str | None) -> str:
    if value is None:
        return "None"
    return str(value)

# Type guards
def is_string(value: Any) -> bool:
    return isinstance(value, str)

# Protocol classes
class Drawable(Protocol):
    def draw(self) -> None:
        ...

class Circle:
    def draw(self) -> None:
        print("Drawing circle")

# Literal types
from typing import Literal

def process_mode(mode: Literal["read", "write", "append"]) -> None:
    pass

# TypedDict
from typing import TypedDict

class PersonDict(TypedDict):
    name: str
    age: int
    email: Optional[str]

# ===========================
# 48. MAIN EXECUTION
# ===========================
def main():
    """Main function to demonstrate various features"""
    print("Python Kitchen Sink - Comprehensive Examples")
    print("=" * 50)
    
    # Run some examples
    print("\n1. Control Flow Examples:")
    control_flow_examples()
    
    print("\n2. Generator Examples:")
    for value in generator_function():
        print(f"Generated: {value}")
    
    print("\n3. Class Examples:")
    obj = BasicClass("test")
    print(f"Instance method: {obj.instance_method()}")
    print(f"Class method: {BasicClass.class_method()}")
    print(f"Static method: {BasicClass.static_method()}")
    
    print("\n4. Comprehension Examples:")
    print(f"List comprehension: {list_comp[:5]}")
    print(f"Dict comprehension: {dict_comp}")
    
    print("\n5. Async Example:")
    # Run async function
    result = asyncio.run(async_function())
    print(f"Async result: {result}")
    
    print("\n6. Design Pattern Example:")
    # Factory pattern
    animal = AnimalFactory.create_animal("dog")
    print(f"Animal says: {animal.speak()}")
    
    # Observer pattern
    subject = Subject()
    observer = Observer()
    subject.attach(observer)
    subject.notify("Hello, Observer!")
    
    print("\nKitchen Sink examples completed!")

if __name__ == "__main__":
    main()