def my_decorator(func):
    def wrapper():
        print("কিছু করার আগে")
        func()
        print("কিছু করার পরে")
    return wrapper
 
@my_decorator
def say_hello():
    print("হ্যালো!")
 
# কল করা
say_hello()

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("কিছু করার আগে")
        result = func(*args, **kwargs)
        print("কিছু করার পরে")
        return result
    return wrapper
 
@my_decorator
def add(a, b):
    return a + b
 
# কল করা
result = add(3, 5)
print(f"ফলাফল: {result}")

def repeat(n=1):
    def decorator(func):
        def wrapper(*args, **kwargs):
            result = None
            for _ in range(n):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator
 
@repeat(n=3)
def say_hello(name):
    print(f"হ্যালো, {name}!")
 
say_hello("রহিম")

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b
 
# ক্লাস ইন্সট্যান্স না করেই কল করা যায়
result = MathUtils.add(5, 3)
print(result)  # 8

class Person:
    count = 0
 
    def __init__(self, name):
        self.name = name
        Person.count += 1
 
    @classmethod
    def number_of_people(cls):
        return cls.count
 
# লোক তৈরি
person1 = Person("আলী")
person2 = Person("করিম")
 
# ক্লাস মেথড কল
print(Person.number_of_people())  # 2

class Circle:
    def __init__(self, radius):
        self._radius = radius
 
    @property
    def radius(self):
        return self._radius
 
    @radius.setter
    def radius(self, value):
        if value <= 0:
            raise ValueError("ব্যাসার্ধ ধনাত্মক হতে হবে")
        self._radius = value
 
    @property
    def area(self):
        return 3.14159 * self._radius ** 2
 
# ব্যবহার
circle = Circle(5)
print(circle.radius)  # 5
print(circle.area)    # ~78.54
 
# সেটারের ব্যবহার
circle.radius = 10
print(circle.area)    # ~314.16
 
# ভুল ইনপুট দিলে এরর দেখাবে
# circle.radius = -1  # ValueError: ব্যাসার্ধ ধনাত্মক হতে হবে

import time
 
def timing_decorator(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:.6f} সেকেন্ড সময় লেগেছে")
        return result
    return wrapper
 
@timing_decorator
def slow_function():
    import time
    time.sleep(1)
    return "কাজ শেষ!"
 
print(slow_function())

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"কল করছি: {func.__name__}, আর্গুমেন্ট: {args}, কিওয়ার্ড আর্গুমেন্ট: {kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} থেকে রিটার্ন: {result}")
        return result
    return wrapper
 
@log_decorator
def calculate_square(x):
    return x * x
 
calculate_square(5)

def memoize(func):
    cache = {}
    def wrapper(*args):
        if args in cache:
            return cache[args]
        result = func(*args)
        cache[args] = result
        return result
    return wrapper
 
@memoize
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)
 
# আগে এটি খুব ধীর হত, এখন দ্রুত
print(fibonacci(35))

import time
from functools import wraps
 
def rate_limit(max_calls, period):
    calls = []
 
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            now = time.time()
 
            # পুরানো কলগুলি সরানো
            while calls and calls[0] < now - period:
                calls.pop(0)
 
            if len(calls) >= max_calls:
                raise Exception(f"রেট লিমিট অতিক্রান্ত! সর্বোচ্চ {max_calls} কল প্রতি {period} সেকেন্ডে")
 
            calls.append(now)
            return func(*args, **kwargs)
 
        return wrapper
 
    return decorator
 
# প্রতি 5 সেকেন্ডে 2টি কল সীমাবদ্ধ করা
@rate_limit(2, 5)
def api_call():
    return "API কল সফল"
 
# ব্যবহার
print(api_call())  # API কল সফল
print(api_call())  # API কল সফল
# print(api_call())  # এরর: রেট লিমিট অতিক্রান্ত!