Practice Questions — Decorators and Iterators

class EvenNumbers:
    def __init__(self, start, stop):
        self.stop = stop
        self.current = start if start % 2 == 0 else start + 1
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.current > self.stop:
            raise StopIteration
        value = self.current
        self.current += 2
        return value

print("For loop:", end=" ")
for n in EvenNumbers(1, 10):
    print(n, end=" ")
print()

print(f"As list: {list(EvenNumbers(0, 9))}")

it = EvenNumbers(4, 9)
print(f"next: {next(it)}, {next(it)}, {next(it)}")

from functools import wraps

def logger(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        args_str = ", ".join([repr(a) for a in args] + [f"{k}={v!r}" for k, v in kwargs.items()])
        print(f"Calling {func.__name__}({args_str})")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result}")
        return result
    return wrapper

@logger
def add(a, b):
    """Add two numbers."""
    return a + b

result = add(3, 5)
print(f"Result: {result}")
print(f"add.__name__: {add.__name__}")
print(f"add.__doc__: {add.__doc__}")

from itertools import combinations, product, count, islice, chain

# 1. All 2-letter combinations from ABCD
combos = list(combinations('ABCD', 2))
print(f"2-letter combos: {len(combos)} total")

# 2. All 3-digit binary numbers
binary = list(product([0, 1], repeat=3))
print(f"Binary 3-digit: {len(binary)} total, first: {binary[0]}")

# 3. First 8 from counter starting at 100, step 5
counter_vals = list(islice(count(100, 5), 8))
print(f"Counter: {counter_vals}")

# 4. Chain three lists
result = list(chain([1, 2], [3, 4], [5, 6]))
print(f"Chained: {result}")

from functools import wraps

def memoize(func):
    cache = {}
    
    @wraps(func)
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    
    wrapper.cache = cache
    wrapper.clear_cache = lambda: cache.clear()
    return wrapper

@memoize
def fib(n):
    if n < 2:
        return n
    return fib(n - 1) + fib(n - 2)

print(f"fib(10) = {fib(10)}")
print(f"fib(20) = {fib(20)}")
print(f"Cache size: {len(fib.cache)}")
fib.clear_cache()
print(f"After clear: {len(fib.cache)}")

import random
from itertools import product

class Deck:
    RANKS = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
    SUITS = ['Hearts', 'Diamonds', 'Clubs', 'Spades']
    
    def __init__(self):
        self.cards = [(r, s) for r, s in product(self.RANKS, self.SUITS)]
    
    def __iter__(self):
        return iter(self.cards)
    
    def __len__(self):
        return len(self.cards)
    
    def shuffle(self):
        random.shuffle(self.cards)
        return self

deck = Deck()
print(f"Total cards: {len(deck)}")

first_3 = [card for _, card in zip(range(3), deck)]
print(f"First 3: {first_3}")

random.seed(42)
deck.shuffle()
first_3_shuffled = [card for _, card in zip(range(3), deck)]
print(f"After shuffle (first 3): {first_3_shuffled}")

from functools import wraps

def requires_role(role):
    def decorator(func):
        @wraps(func)
        def wrapper(user, *args, **kwargs):
            if user.role != role:
                raise PermissionError(
                    f"{user.name} requires '{role}' role, has '{user.role}'"
                )
            return func(user, *args, **kwargs)
        return wrapper
    return decorator

class User:
    def __init__(self, name, role):
        self.name = name
        self.role = role

@requires_role('admin')
def admin_panel(user):
    return f"Welcome, {user.name}"

@requires_role('admin')
def delete_user(user, target):
    return f"{user.name} deleted {target}"

admin = User("Aarav", "admin")
viewer = User("Priya", "viewer")

print(f"Admin panel: {admin_panel(admin)}")

try:
    admin_panel(viewer)
except PermissionError as e:
    print(f"PermissionError: {e}")

class InfiniteCounter:
    def __init__(self, start=0, step=1):
        self.current = start
        self.step = step
    
    def __iter__(self):
        return self
    
    def __next__(self):
        value = self.current
        self.current += self.step
        return value

class Cycle:
    def __init__(self, iterable):
        self.items = list(iterable)
        self.index = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if not self.items:
            raise StopIteration
        value = self.items[self.index]
        self.index = (self.index + 1) % len(self.items)
        return value

class TakeWhile:
    def __init__(self, predicate, iterator):
        self.predicate = predicate
        self.iterator = iter(iterator)
        self.done = False
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.done:
            raise StopIteration
        value = next(self.iterator)
        if not self.predicate(value):
            self.done = True
            raise StopIteration
        return value

class Chain:
    def __init__(self, *iterables):
        self.iterables = iter(iterables)
        self.current = iter([])
    
    def __iter__(self):
        return self
    
    def __next__(self):
        while True:
            try:
                return next(self.current)
            except StopIteration:
                self.current = iter(next(self.iterables))

# Test
counter = InfiniteCounter(5, 3)
print(f"Counter: {[next(counter) for _ in range(5)]}")

cycler = Cycle(['a', 'b', 'c'])
print(f"Cycle: {[next(cycler) for _ in range(5)]}")

tw = TakeWhile(lambda x: x < 7, [1, 3, 5, 7, 9, 2])
print(f"TakeWhile: {list(tw)}")

ch = Chain([1, 2], [3, 4], [5, 6])
print(f"Chain: {list(ch)}")

import time
from functools import wraps
import inspect

def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

def retry(max_attempts=3, exceptions=(Exception,)):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, max_attempts + 1):
                try:
                    result = func(*args, **kwargs)
                    print(f"Attempt {attempt} succeeded.")
                    return result
                except exceptions as e:
                    print(f"Attempt {attempt} failed. Retrying...")
                    if attempt == max_attempts:
                        raise
        return wrapper
    return decorator

def type_check(**expected_types):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            sig = inspect.signature(func)
            params = list(sig.parameters.keys())
            for i, arg in enumerate(args):
                if i < len(params) and params[i] in expected_types:
                    if not isinstance(arg, expected_types[params[i]]):
                        raise TypeError(
                            f"Expected {params[i]} to be {expected_types[params[i]]}, "
                            f"got {type(arg)}"
                        )
            return func(*args, **kwargs)
        return wrapper
    return decorator

@timer
def slow_func():
    time.sleep(0.1)
    return "done"

slow_func()

call_count = 0
@retry(max_attempts=3, exceptions=(ValueError,))
def flaky():
    global call_count
    call_count += 1
    if call_count < 2:
        raise ValueError("random failure")
    return "success"

flaky()

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

print(f"add(3, 5) = {add(3, 5)}")
try:
    add(3, "5")
except TypeError as e:
    print(f"TypeError: {e}")