Decorators & Advanced Features

# Step 1: Define the decorator function
def my_decorator(fn):      # Takes a function as input
    # Step 2: Create an inner "wrapper" function
    def wrapper():
        print("Before")    # Runs BEFORE the original function
        fn()               # Call the original function
        print("After")     # Runs AFTER the original function
    # Step 3: Return the wrapper (don't call it!)
    return wrapper

# Step 4: Apply decorator using @ syntax
@my_decorator
def hello():
    print("Hello!"
...

from functools import wraps

# ❌ BAD: Without wraps - loses metadata
def bad_decorator(fn):
    def wrapper(*a, **k):
        return fn(*a, **k)
    return wrapper  # Returns wrapper, not fn!

@bad_decorator
def greet():
    """Says hello"""
    return "Hello!"

print("Without @wraps:")
print(f"  Name: {greet.__name__}")  # 'wrapper' - WRONG!
print(f"  Doc: {greet.__doc__}")    # None - WRONG!

# ✅ GOOD: With wraps - preserves metadata
def good_decorator(fn):
    @wraps(fn)  # ← This line fixes 
...

from functools import wraps

# Layer 1: Outer function accepts the argument
def check_role(required_role):
    # Layer 2: This is the actual decorator
    def decorator(fn):
        @wraps(fn)
        # Layer 3: This is the wrapper that runs
        def wrapper(user, *args, **kwargs):
            if user.get("role") != required_role:
                raise PermissionError(f"Access denied. Required: {required_role}")
            return fn(user, *args, **kwargs)
        return wrapper
    return de
...

from functools import wraps

def decorator_A(fn):
    @wraps(fn)
    def wrapper(*a, **k):
        print("A: before")   # Runs 1st
        result = fn(*a, **k) # Calls B's wrapper
        print("A: after")    # Runs 6th
        return result
    return wrapper

def decorator_B(fn):
    @wraps(fn)
    def wrapper(*a, **k):
        print("B: before")   # Runs 2nd
        result = fn(*a, **k) # Calls the real function
        print("B: after")    # Runs 4th
        return result
    return wrapper

...

import time
from functools import wraps

def timer(fn):
    @wraps(fn)
    def wrapper(*a, **k):
        start = time.time()
        result = fn(*a, **k)
        print(f"⏱ {fn.__name__} took {time.time() - start:.4f}s")
        return result
    return wrapper

def logger(fn):
    @wraps(fn)
    def wrapper(*a, **k):
        print(f"📘 Calling {fn.__name__}")
        return fn(*a, **k)
    return wrapper

def cache(fn):
    saved = {}
    @wraps(fn)
    def wrapper(x):
        if x in saved:
   
...

from functools import wraps
import time
import random

def retry(times):
    def decorator(fn):
        @wraps(fn)
        def wrapper(*args, **kwargs):
            for i in range(times):
                try:
                    return fn(*args, **kwargs)
                except Exception as e:
                    print(f"Retry {i+1}/{times}: {e}")
                    time.sleep(0.1)
            raise RuntimeError("All retries failed")
        return wrapper
    return decorator

@retry(3)
def un
...

from functools import wraps

def validate_types(*types):
    def decorator(fn):
        @wraps(fn)
        def wrapper(*args):
            for arg, expected in zip(args, types):
                if not isinstance(arg, expected):
                    raise TypeError(f"Expected {expected.__name__}, got {type(arg).__name__}")
            return fn(*args)
        return wrapper
    return decorator

@validate_types(int, int)
def add(a, b):
    return a + b

print(add(5, 3))

try:
    print(add("5", 3)
...

from functools import wraps

def require_roles(*allowed):
    def decorator(fn):
        @wraps(fn)
        def wrapper(user, *a, **k):
            if user.get("role") not in allowed:
                return f"Access denied. Allowed roles: {allowed}"
            return fn(user, *a, **k)
        return wrapper
    return decorator

@require_roles("admin", "moderator")
def edit_post(user, post_id):
    return f"{user['name']} edited post {post_id}"

admin = {"name": "Alice", "role": "admin"}
mod = 
...

from functools import wraps

def log(prefix="INFO", suffix=""):
    def decorator(fn):
        @wraps(fn)
        def wrapper(*a, **k):
            print(f"[{prefix}] Calling {fn.__name__} {suffix}")
            return fn(*a, **k)
        return wrapper
    return decorator

@log(prefix="DEBUG", suffix="- testing")
def load_config():
    return {"debug": True}

@log(prefix="WARN")
def risky_operation():
    return "done"

load_config()
risky_operation()

from functools import wraps

class RateLimiter:
    def __init__(self, limit):
        self.limit = limit   # Max allowed calls
        self.calls = 0       # State: track call count
    
    def __call__(self, fn):  # Makes the class callable as decorator
        @wraps(fn)
        def wrapper(*a, **k):
            if self.calls >= self.limit:
                return f"Rate limit exceeded ({self.limit} calls max)"
            self.calls += 1  # Update state
            return fn(*a, **k)
       
...

from functools import wraps
import time

def logger(fn):
    @wraps(fn)
    def wrapper(*a, **k):
        print(f"📘 {fn.__name__} called")
        return fn(*a, **k)
    return wrapper

def timer(fn):
    @wraps(fn)
    def wrapper(*a, **k):
        start = time.time()
        result = fn(*a, **k)
        print(f"⏱ {time.time() - start:.4f}s")
        return result
    return wrapper

def retry(times):
    def decorator(fn):
        @wraps(fn)
        def wrapper(*a, **k):
            for i in 
...