Python 데코레이터+컨텍스트 매니저 합치기 5패턴

from __future__ import annotations

import time
from contextlib import ContextDecorator


class timed(ContextDecorator):
    def __init__(self, name: str = ""):
        self.name = name
        self._start = 0.0

    def __enter__(self):
        self._start = time.perf_counter()
        return self

    def __exit__(self, exc_type, exc, tb):
        elapsed = time.perf_counter() - self._start
        label = self.name or "block"
        print(f"[timed] {label}: {elapsed:.6f}s")
        # 예외를 삼키지 않음
        return False


@timed("expensive")
def expensive_work():
    time.sleep(0.1)


def main():
    expensive_work()

    with timed("manual"):
        time.sleep(0.05)


if __name__ == "__main__":
    main()

from __future__ import annotations

from contextlib import contextmanager
from functools import wraps


def with_ctx(ctx_factory):
    """ctx_factory는 호출 시 컨텍스트 매니저를 반환하는 callable."""

    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            with ctx_factory(*args, **kwargs):
                return func(*args, **kwargs)

        return wrapper

    return decorator


@contextmanager
def request_scope(request_id: str):
    print(f"scope enter: {request_id}")
    try:
        yield
    finally:
        print(f"scope exit: {request_id}")


@with_ctx(lambda request_id: request_scope(request_id))
def handle(request_id: str):
    print(f"handling {request_id}")


def main():
    handle("req-1")
    with request_scope("req-2"):
        print("manual")


if __name__ == "__main__":
    main()

from __future__ import annotations

from contextlib import ContextDecorator


class Scope(ContextDecorator):
    def __init__(self, name: str):
        self.name = name

    def __enter__(self):
        print(f"enter {self.name}")
        return self

    def __exit__(self, exc_type, exc, tb):
        print(f"exit {self.name}")
        return False


class scope:
    """scope("x")가 컨텍스트 매니저이자 데코레이터가 되게 하는 팩토리."""

    def __init__(self, name: str):
        self._name = name

    def __enter__(self):
        return Scope(self._name).__enter__()

    def __exit__(self, exc_type, exc, tb):
        return Scope(self._name).__exit__(exc_type, exc, tb)

    def __call__(self, func):
        # ContextDecorator를 직접 쓰는 편이 더 간단하지만,
        # 여기서는 “팩토리 객체가 데코레이터로도 동작”하는 형태를 보여줌
        scoped = Scope(self._name)
        return scoped(func)


@scope("job")
def run():
    print("running")


def main():
    run()
    with scope("block"):
        print("in block")


if __name__ == "__main__":
    main()

from __future__ import annotations

from contextlib import ContextDecorator, ExitStack, contextmanager


@contextmanager
def envvar(key: str, value: str):
    import os

    old = os.environ.get(key)
    os.environ[key] = value
    try:
        yield
    finally:
        if old is None:
            os.environ.pop(key, None)
        else:
            os.environ[key] = old


@contextmanager
def traced(name: str):
    print(f"trace start: {name}")
    try:
        yield
    finally:
        print(f"trace end: {name}")


class composed(ContextDecorator):
    def __init__(self, *cms):
        self._cms = cms
        self._stack = None

    def __enter__(self):
        stack = ExitStack()
        for cm in self._cms:
            stack.enter_context(cm)
        self._stack = stack
        return self

    def __exit__(self, exc_type, exc, tb):
        assert self._stack is not None
        return self._stack.__exit__(exc_type, exc, tb)


@composed(traced("job"), envvar("MODE", "prod"))
def job():
    import os

    print("MODE=", os.environ.get("MODE"))


def main():
    job()

    with composed(traced("block"), envvar("MODE", "dev")):
        job()


if __name__ == "__main__":
    main()

from __future__ import annotations

from contextlib import asynccontextmanager
from functools import wraps


def async_with_ctx(ctx_factory):
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            async with ctx_factory(*args, **kwargs):
                return await func(*args, **kwargs)

        return wrapper

    return decorator


@asynccontextmanager
async def async_timed(name: str):
    import time

    start = time.perf_counter()
    try:
        yield
    finally:
        elapsed = time.perf_counter() - start
        print(f"[async_timed] {name}: {elapsed:.6f}s")


@async_with_ctx(lambda name: async_timed(name))
async def fetch(name: str):
    import asyncio

    await asyncio.sleep(0.05)
    return name


async def main():
    await fetch("io")


if __name__ == "__main__":
    import asyncio

    asyncio.run(main())