# api-server/app/core/transactional.py
class Transactional:
    commit: bool

    def __init__(self, commit: bool = True, readonly: bool = False):
        self.commit = commit and (not readonly)

    def __call__(self, func: Callable):
        @wraps(func)
        def wrapper(*args, **kwargs):
            self_obj = args[0] if args else None
            session = self._get_session()
            original_sessions: Dict[str, Session] = {}
            try:
                if self_obj is not None:
                    original_sessions = self._inject_session(self_obj, session)
                result = func(*args, **kwargs)
                if self.commit:
                    session.commit()
                return result
            except Exception:
                session.rollback()
                raise
            finally:
                if self_obj is not None:
                    self._restore_sessions(self_obj, original_sessions)
                session.close()
        return wrapper

# api-server/app/utils/rerankers/reranker.py
_RERANKER: Dict[str, Reranker] = {}

def register_reranker(name: str):
    def decorator(func):
        _RERANKER[name] = func
        return func
    return decorator

def get_reranker(name: str, **kwargs) -> Reranker:
    reranker = _RERANKER.get(name.lower())
    if reranker is None:
        raise InvalidValueException("유효하지 않은 알고리즘입니다.")
    return reranker(**kwargs)

# api-server/app/core/containers.py
class RdbContainer(containers.DeclarativeContainer):
    db = providers.Singleton(SyncDatabase)
    session = providers.Callable(lambda db: db.session, db=db)

class Container(containers.DeclarativeContainer):
    wiring_config = containers.WiringConfiguration(
        modules=["app.controllers.pr_controller", ...]
    )
    settings = providers.Singleton(load_settings)
    logger = providers.Singleton(LoggerConfig.load_logger)
    infra = providers.Container(RdbContainer)

    pr_log_repository = providers.Factory(PostgresqlPrLogRepository, db=infra.session)
    ...
    pr_service = providers.Factory(
        PrServiceImpl,
        pr_log_repository=pr_log_repository,
        pr_detail_repository=pr_detail_repository,
        change_file_repository=change_file_repository,
        dist_group_repository=dist_group_repository,
        search_request_repository=search_request_repository,
        change_file_service=change_file_service,
        gh=gh,
        logger=logger,
        settings=settings,
    )

# api-server/app/controllers/pr_controller.py
@inject
def pr_controller(
    pr_service: PrService = Depends(Provide[Container.pr_service]),
    change_file_service: ChangeFileService = Depends(Provide[Container.change_file_service]),
    ...
) -> APIRouter:
    router = APIRouter(prefix="/repos", tags=["pr 조회"])

    @router.get("/pulls/statistics")
    def pr_statistics(request: Request):
        stats = pr_service.get_today_statistics()
        return BaseResponse.success_response(data=DistGroupStatusSummaryOut(stats=stats))

# api-server/app/services/implementation/pr_service_impl.py
class PrServiceImpl(PrService):
    @Transactional()
    async def create(self, pr_webhook: PrWebhook) -> None:
        pr_log = self.pr_log_repository.get_log(pr_webhook.pr_id)
        if pr_log:
            pr_log.title = pr_webhook.title
            self.pr_log_repository.update_log(pr_log)
        else:
            pr_log = PrLog(...)
            self.pr_log_repository.create_log(pr_log)

        pr_detail = PrDetail(commit_sha=pr_webhook.head_sha, ...)
        self.pr_detail_repository.create(pr_detail)
        change_files = await self.change_file_service.save_change_file(
            pr_log,
            change_file_repository=self.change_file_repository,
            ...
        )