[AI Assignment - Python] 🎀 데코레이터 완전 정복 — timer, retry, validate_types 직접 구현

def my_decorator(func):
    def wrapper(*args, **kwargs):
        # 함수 실행 전에 할 일
        result = func(*args, **kwargs)
        # 함수 실행 후에 할 일
        return result
    return wrapper

# @my_decorator는 사실 이것과 같습니다:
# say_hello = my_decorator(say_hello)

def repeat(n: int):           # ← 데코레이터 팩토리
    def decorator(func):      # ← 실제 데코레이터
        def wrapper(*args, **kwargs):
            ...
        return wrapper
    return decorator

def timer(func):
    def running_check(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        if result == 'done':
            text = f"출력: slow_function 실행 시간: {end_time - start_time:.2f}초"
        return text
    print(running_check().__repr__())
    return running_check

# 실행 타이밍 이해
@timer                    # ← 이 시점에 timer(slow_function) 실행
def slow_function():      #    → wrapper를 반환만 해야 함
    ...

slow_function()           # ← 이 시점에 wrapper() 실행

def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"{func.__name__} 실행 시간: {elapsed:.2f}초")
        return result
    return wrapper

def retry(max_attempts: int):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(max_attempts):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

# __main__에서 직접 재시도 — 데코레이터의 의미가 없어짐
for i in range(max_attempts):
    try:
        check = unstable_api_call()
        if check['status'] == 'ok':
            break
    except Exception as e:
        print(f"시도 {i+1}/{max_attempts} 실패: {e}")

def wrapper(*args, **kwargs):
    last_exception = None
    for i in range(max_attempts):
        try:
            result = func(*args, **kwargs)
            print(f"{func.__name__} 시도 {i+1}/{max_attempts} 성공")
            return result
        except Exception as e:
            last_exception = e
            print(f"{func.__name__} 시도 {i+1}/{max_attempts} 실패: {e}")
    return last_exception   # ← 문제!

def wrapper(*args, **kwargs):
    last_exception = None
    try:
        for i in range(max_attempts):
            try:
                result = func(*args, **kwargs)
                return result
            except Exception as e:
                last_exception = e
                break
    except Exception as e:
        raise last_exception

def retry(max_attempts: int):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            last_exception = None
            for i in range(max_attempts):
                try:
                    result = func(*args, **kwargs)
                    print(f"{func.__name__} 시도 {i+1}/{max_attempts} 성공")
                    return result
                except Exception as e:
                    last_exception = e
                    print(f"{func.__name__} 시도 {i+1}/{max_attempts} 실패: {e}")
            raise last_exception
        return wrapper
    return decorator

def validate_types(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        for arg in args:
            if not isinstance(arg, int):
                raise TypeError(f"인자는 정수(int)여야 합니다. 받은 타입: {type(arg)}")
        return func(*args, **kwargs)
    return wrapper

for param_name, value in zip(params, args):
    if not isinstance(value, hints[param_name]):
        raise TypeError(f"인자는 정수(int)여야 합니다. 받은 타입: {type(param_name)}")

def validate_types(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        hints = get_type_hints(func)
        sig = inspect.signature(func)
        params = list(sig.parameters.keys())

        for param_name, value in zip(params, args):
            if not isinstance(value, hints[param_name]):
                raise TypeError(
                    f"'{param_name}'의 타입이 {hints[param_name].__name__}여야 하지만 "
                    f"{type(value).__name__}이 전달됨"
                )
        return func(*args, **kwargs)
    return wrapper

@timer
def slow_function():
    """느린 함수입니다"""
    ...

# @wraps 없이
print(slow_function.__name__)    # → "wrapper"     ← 원래 이름 소실
print(slow_function.__doc__)     # → None           ← docstring 소실

# @wraps 있으면
print(slow_function.__name__)    # → "slow_function"
print(slow_function.__doc__)     # → "느린 함수입니다"

def add(a: int, b: int) -> int:
    return a + b

add("hello", "world")   # → "helloworld" (에러 없음!)
add(1.5, 2.3)            # → 3.8 (int 아닌데 에러 없음!)

# 데코레이터 없이 — 재시도 로직이 매번 반복
def call_openai():
    for i in range(3):
        try: return openai.chat(...)
        except: ...

def call_anthropic():
    for i in range(3):              # ← 똑같은 코드
        try: return anthropic.messages(...)
        except: ...

# 데코레이터로 — 비즈니스 로직만 남음
@retry(max_attempts=3)
def call_openai():
    return openai.chat(...)

@retry(max_attempts=3)
def call_anthropic():
    return anthropic.messages(...)