Advanced Python: Metaclasses, Decorators, and Context Managers

Metaclasses are the 'classes of classes.' They control how classes are created. By using metaclasses, you can customize class creation, enforce rules, and add behavior at the class definition level. This allows for powerful abstractions and is particularly useful for framework design or enforcing consistent class structures.

Example: Creating a metaclass to enforce specific attribute types:

class AttributeTypeEnforcer(type):
    def __new__(mcs, name, bases, attrs):
        for attr_name, attr_value in attrs.items():
            if attr_name in ['age', 'salary']:
                if not isinstance(attr_value, (int, float)):
                    raise TypeError(f"{attr_name} must be an int or float")
            if attr_name == 'name':
                if not isinstance(attr_value, str):
                    raise TypeError("Name must be a string")
        return super().__new__(mcs, name, bases, attrs)

class Person(metaclass=AttributeTypeEnforcer):
    name = "Alice"
    age = 30
    salary = 50000.0
    # name = 123  # This would raise a TypeError

person = Person()
print(person.name, person.age, person.salary)

Explanation:
* __new__ is a special method in a metaclass that's called before the class is created. It receives the class's name, base classes, and attributes.
* We iterate through the attributes and check their types. If the type is incorrect, we raise a TypeError before the class is created.
* This ensures that all instances of Person will always have age and salary as numeric values and name as string values.

Decorators are a concise and elegant way to modify or enhance the behavior of functions or methods. They wrap functions to add functionality, without changing the function's core code. Decorators are essentially syntactic sugar for function wrappers.

Example: Timing a function's execution:

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} took {end_time - start_time:.4f} seconds")
        return result
    return wrapper

@timer
def calculate_sum(n):
    total = 0
    for i in range(n):
        total += i
    return total

result = calculate_sum(1000000)
print(result)

Explanation:
* timer is the decorator function. It takes the function to be decorated (func) as an argument.
* wrapper is the inner function that does the actual work of measuring time and calling the original function.
* The @timer syntax is the 'syntactic sugar' which is equivalent to calculate_sum = timer(calculate_sum).
* This approach avoids altering the original function's core logic and keeps code clean.

Advanced Decorator: Type Hint Validation:

from typing import get_type_hints, Any
import functools

def type_check(func):
    hints = get_type_hints(func)
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        # Check positional arguments
        arg_names = func.__code__.co_varnames[:func.__code__.co_argcount]
        for i, arg in enumerate(args):
            if arg_names[i] in hints and not isinstance(arg, hints[arg_names[i]]):
                raise TypeError(f"Argument '{arg_names[i]}' must be of type {hints[arg_names[i]].__name__}, got {type(arg).__name__}")
        # Check keyword arguments (not covered, but can be done similar to positional args)
        return func(*args, **kwargs)
    return wrapper

@type_check
def add(x: int, y: int) -> int:
    return x + y

# add(1, "2") # This will raise TypeError
print(add(1,2)) # This will work

Explanation:
* This decorator uses get_type_hints to inspect the function's type hints.
* It checks if the arguments passed to the function match the type hints provided. If not, it raises a TypeError.

Context managers are designed to handle resources safely, ensuring that they are properly acquired and released, even if exceptions occur. They typically use the with statement. The key methods are __enter__ (executed when entering the with block) and __exit__ (executed when exiting the with block, regardless of exceptions).

Example: File Handling Context Manager:

class FileHandler:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None

    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.file:
            self.file.close()
        # Handle exceptions if needed
        if exc_type:
            print(f"An exception of type {exc_type} occurred")
            return False # re-raise the exception
        return True # if no exception occur

with FileHandler('my_file.txt', 'w') as f:
    f.write('Hello, context manager!')

# The file is automatically closed when exiting the 'with' block

with FileHandler('my_file.txt', 'r') as f:
    content = f.read()
    print(content)

Explanation:
* __enter__: Opens the file and returns the file object. It's called when the with block starts.
* __exit__: Closes the file, regardless of whether an exception occurred within the with block. It receives the exception type, value, and traceback (if any). The return value determines whether the exception should be re-raised (returning False) or suppressed (returning True).
* This pattern ensures that the file is always closed, preventing resource leaks, and handles any errors.