Iterator, Generator, Decorator, Context Manager

items = ["আম", "জাম"]
it = iter(items)        # একটা iterator চাও
print(next(it))         # আম
print(next(it))         # জাম
print(next(it))         # StopIteration exception, মানে শেষ

squares_list = [n * n for n in range(10_000_000)]   # সব একসাথে memory তে: প্রায় ৪০০ MB
squares_gen = (n * n for n in range(10_000_000))    # কিছুই বানায়নি এখনো: কয়েক byte

def read_large_log(path: str):
    """বিশাল log file থেকে শুধু ERROR লাইন, একটা একটা করে।"""
    with open(path, encoding="utf-8") as f:
        for line in f:                 # file ও একটা iterator, পুরোটা memory তে আনে না
            if "ERROR" in line:
                yield line.strip()     # একটা দিয়ে থামে, পরের বার এখান থেকে চলে


for error_line in read_large_log("app.log"):
    print(error_line)

def lines(path):
    with open(path, encoding="utf-8") as f:
        yield from f                         # f এর প্রতিটা লাইন yield করো

def only_errors(rows):
    return (r for r in rows if "ERROR" in r)

def parse(rows):
    for r in rows:
        date, time, level, *msg = r.split()
        yield {"time": f"{date} {time}", "message": " ".join(msg)}

errors = parse(only_errors(lines("app.log")))
for e in errors:
    print(e["time"], e["message"])

import time
import functools


def timed(func):
    @functools.wraps(func)                 # মূল function এর নাম, docstring ঠিক রাখে
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)     # আসল function চালাও
        elapsed = (time.perf_counter() - start) * 1000
        print(f"{func.__name__} নিল {elapsed:.1f} ms")
        return result
    return wrapper


@timed
def generate_report(n: int) -> int:
    return sum(i * i for i in range(n))


generate_report(1_000_000)     # generate_report নিল 52.3 ms

generate_report = timed(generate_report)

import random
import time
import functools


def retry(times: int = 3, delay: float = 0.5, exceptions: tuple = (ConnectionError,)):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, times + 1):
                try:
                    return func(*args, **kwargs)
                except exceptions as e:
                    if attempt == times:
                        raise
                    wait = delay * 2 ** (attempt - 1)      # 0.5, 1, 2 ... (exponential backoff)
                    print(f"চেষ্টা {attempt} ব্যর্থ ({e}), {wait}s পর আবার")
                    time.sleep(wait)
        return wrapper
    return decorator


@retry(times=4, delay=0.2)
def flaky_api() -> str:
    if random.random() < 0.6:
        raise ConnectionError("timeout")
    return "সফল"

print(flaky_api())

from functools import lru_cache, cache

@lru_cache(maxsize=1000)            # একই input এর ফলাফল মনে রাখে (memoization)
def exchange_rate(currency: str) -> float:
    print("API call...")             # দ্বিতীয়বার একই currency তে এটা চলবে না
    return 120.5

# অন্যান্য: @property, @staticmethod, @classmethod, @dataclass
# FastAPI: @app.get("/"), @app.post("/orders")
# pytest: @pytest.fixture, @pytest.mark.parametrize

with open("data.json", encoding="utf-8") as f:
    data = f.read()
# এখানে f নিজে থেকেই বন্ধ, মাঝে error হলেও

from contextlib import contextmanager
import time


@contextmanager
def timer(label: str):
    start = time.perf_counter()
    try:
        yield                                  # with block এর ভেতরের code এখানে চলে
    finally:
        print(f"{label}: {(time.perf_counter() - start) * 1000:.1f} ms")


with timer("report"):
    total = sum(range(5_000_000))

@contextmanager
def transaction(conn):
    try:
        yield conn
        conn.commit()          # ভেতরে কোনো error না হলে
    except Exception:
        conn.rollback()        # error হলে সব বাতিল, অর্ধেক কাজ থাকবে না
        raise


with transaction(conn) as c:
    c.execute("UPDATE accounts SET balance = balance - 500 WHERE id = 1")
    c.execute("UPDATE accounts SET balance = balance + 500 WHERE id = 2")
# দুটো একসাথে হবে, নয়তো একটাও না

class Timer:
    def __enter__(self):
        self.start = time.perf_counter()
        return self

    def __exit__(self, exc_type, exc, tb):
        self.ms = (time.perf_counter() - self.start) * 1000
        return False      # False মানে exception হলে সেটা চাপা দিও না

with Timer() as t:
    sum(range(1_000_000))
print(t.ms)