Decorators و Context Managers 🎭

# یک decorator ساده برای اندازه‌گیری زمان اجرا
import time
import functools

def timer(func):
    """Decorator برای اندازه‌گیری زمان اجرای تابع"""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"⏱️ تابع {func.__name__} در {end_time - start_time:.4f} ثانیه اجرا شد")
        return result
    return wrapper

# استفاده از decorator
@timer
def slow_function():
    """یک تابع که کمی طول می‌کشه"""
    time.sleep(1)
    return "کار تمام شد!"

@timer
def calculate_sum(n):
    """محاسبه مجموع اعداد تا n"""
    return sum(range(1, n + 1))

# تست کردن
result1 = slow_function()
print(f"نتیجه: {result1}")

result2 = calculate_sum(1000000)
print(f"مجموع: {result2}")

# خروجی:
# ⏱️ تابع slow_function در 1.0012 ثانیه اجرا شد
# نتیجه: کار تمام شد!
# ⏱️ تابع calculate_sum در 0.0234 ثانیه اجرا شد
# مجموع: 500000500000

# روش قدیمی - خطرناک!
def old_way():
    file = open('data.txt', 'w')
    file.write('سلام دنیا!')
    # اگه اینجا خطایی بیفته، فایل بسته نمی‌شه! 😱
    file.close()

# روش جدید - امن و تمیز!
def new_way():
    with open('data.txt', 'w') as file:
        file.write('سلام دنیا!')
        # حتی اگه خطا بیفته، فایل خودکار بسته می‌شه! 😎

# مثال پیشرفته‌تر
import time
from contextlib import contextmanager

@contextmanager
def timer_context(name):
    """Context manager برای اندازه‌گیری زمان"""
    print(f"🚀 شروع {name}...")
    start_time = time.time()
    try:
        yield  # اینجا کد اصلی اجرا می‌شه
    finally:
        end_time = time.time()
        print(f"⏱️ {name} در {end_time - start_time:.4f} ثانیه تمام شد")

# استفاده از context manager سفارشی
with timer_context("محاسبات سنگین"):
    result = sum(i**2 for i in range(1000000))
    print(f"نتیجه: {result}")

# خروجی:
# 🚀 شروع محاسبات سنگین...
# نتیجه: 333332833333500000
# ⏱️ محاسبات سنگین در 0.1234 ثانیه تمام شد

import functools
import time
from typing import Any, Callable

# Decorator با پارامتر
def retry(max_attempts: int = 3, delay: float = 1.0):
    """Decorator برای تلاش مجدد در صورت خطا"""
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_attempts - 1:
                        raise e
                    print(f"❌ تلاش {attempt + 1} ناموفق: {e}")
                    time.sleep(delay)
            return None
        return wrapper
    return decorator

# Cache decorator
def cache(func: Callable) -> Callable:
    """Decorator برای کش کردن نتایج"""
    cached_results = {}
    
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        # ساخت کلید برای کش
        key = str(args) + str(sorted(kwargs.items()))
        
        if key in cached_results:
            print(f"💾 نتیجه از کش: {func.__name__}")
            return cached_results[key]
        
        result = func(*args, **kwargs)
        cached_results[key] = result
        print(f"🔄 محاسبه جدید: {func.__name__}")
        return result
    
    return wrapper

# استفاده از decorators
@retry(max_attempts=3, delay=0.5)
def unreliable_api_call():
    """تابعی که گاهی خطا می‌ده"""
    import random
    if random.random() < 0.7:  # 70% احتمال خطا
        raise Exception("اتصال به API ناموفق!")
    return "داده‌ها دریافت شد!"

@cache
def fibonacci(n: int) -> int:
    """محاسبه فیبوناچی با کش"""
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# تست کردن
print("=== تست Retry Decorator ===")
try:
    result = unreliable_api_call()
    print(f"✅ موفق: {result}")
except Exception as e:
    print(f"❌ نهایتاً ناموفق: {e}")

print("\n=== تست Cache Decorator ===")
print(f"fibonacci(10) = {fibonacci(10)}")
print(f"fibonacci(10) = {fibonacci(10)}")  # این بار از کش

import time
import functools
from contextlib import contextmanager
from datetime import datetime

# Decorator برای لاگ کردن
def log_calls(func):
    """Decorator که فراخوانی‌های تابع رو لاگ می‌کنه"""
    # کدت رو اینجا بنویس
    pass

# Context Manager برای مدیریت فایل لاگ
@contextmanager
def log_file_manager(filename):
    """Context Manager برای مدیریت فایل لاگ"""
    # کدت رو اینجا بنویس
    pass

# تست کردن
@log_calls
def calculate_sum(numbers):
    time.sleep(0.1)  # شبیه‌سازی محاسبه
    return sum(numbers)

@log_calls
def find_max(numbers):
    time.sleep(0.05)
    return max(numbers)

# استفاده
with log_file_manager("app.log"):
    result1 = calculate_sum([1, 2, 3, 4, 5])
    result2 = find_max([10, 5, 8, 3, 12])
    print(f"مجموع: {result1}, حداکثر: {result2}")