# database.py looks roughly like this

_request_id_ctx_var: contextvars.ContextVar[str] = contextvars.ContextVar('request_id_ctx')

def get_request_id() -> str:
    return _request_id_ctx_var.get()
    
@contextmanager
def db_context(identifier: str):
    ctx_token = _request_id_ctx_var.set(identifier)
    yield
    _request_id_ctx_var.reset(ctx_token)

class Database:
    def __init__(self, db_url: str, pool_size: int) -> None:
        self.db_url = db_url
        self._engine = create_async_engine(
            self.db_url,
            echo=False,
            pool_size=pool_size,
        )
        self._create_factory()

    def _create_factory(self, bind: Union[Connection, Engine, None] = None) -> None:
        bind = bind or self._engine

        self.async_session_factory = sessionmaker(
            bind=bind,
            class_=_AsyncSession,
            expire_on_commit=False,
            autoflush=False,
        )
        self.AsyncSession = async_scoped_session(self.async_session_factory, scopefunc=get_request_id)

    def create_session(self):
        return self.AsyncSession()

# In application.py I set up middlewares to set the context

@app.middleware('http')
async def remove_db_session(request: Request, call_next):
    response = await call_next(request)

    db = container.db()
    await db.AsyncSession.remove()

    return response

@app.middleware('http')
async def set_db_context(request: Request, call_next):
    request_id = str(uuid.uuid4())

    with db_context(identifier=request_id):
        response = await call_next(request)

    return response

# And in containers.py
class Container(containers.DeclarativeContainer):
    db = providers.Singleton(Database, db_url=config.database.url, pool_size=config.database.pool_size)
    db_session = providers.Callable(db.provided.create_session.call())

    user_repository = providers.Factory(UserRepository, session=db_session)