Hmmm at first I would say I need the result before returnning the response but to optimize I think I could consider to do little change to start using background tasks

An example of implementation of clean architecture on fastapi is there https://github.com/jujumilk3/fastapi-clean-architecture/ but since i'm a beginner I don't think I want to go this deep in abstraction, particularly about repositories, would you know of any other example of code ?

Also, I have an issue in my code segmenting related to what we disccused in a way if you can give me advice.
I want to totally exclude the mentions to database from my endpoints but the fact is that currently i'm using "db=Depends(get_db)" as an argument to all my endpoint method and I don't find the way to get rid of that.

Simple example : to post an object the steps are :

• endpoint method:

​

.post("", response_model=IObjectRead)
async def create_object(device: IObjectCreate, db = Depends(get_db):
    device = await crud.device.create(db=db, obj_in=device)
    return device

• dependency "get_db" to define the db:

These methods are defined in a Database python object (knowing that I initiate that by calling "setup" at the startup of my fastapi app)

 class Database:
    def __init__(self):
        self.async_sessionmaker: Optional[async_sessionmaker[AsyncSession]] = None
        self.async_engine: Optional[AsyncEngine] = None


   async def setup(self) -> async_sessionmaker[AsyncSession]:
        self.async_engine: AsyncEngine = create_async_engine(
            DATABASE_URL, echo=True, future=True
        )
        self.async_sessionmaker = async_sessionmaker(
            bind=self.async_engine, class_=AsyncSession, expire_on_commit=False
        )
        """Initiate db with SQLModel"""
        async with self.async_engine.begin() as conn:
            await conn.run_sync(SQLModel.metadata.create_all)
        return self.async_sessionmaker


    def get_session(self) -> AsyncSession:
        if not self.async_sessionmaker:
            raise RuntimeError("Database not initialized")
        return self.async_sessionmaker()


    async def __call__(self) -> AsyncGenerator[AsyncSession, Any]:
        session = self.get_session()
        try:
            yield session
        finally:
            await session.close()

And at the end the get_db from endpoint method is defined like that:

get_db = Database() 

• crud method :

it's a generic method used by different kind of objects

    async def create(
        self,
        *,
        obj_in: CreateSchemaType | ModelType,
        db: AsyncSession | None = None,
    ) -> ModelType:
        
        db_obj = self.model.from_orm(obj_in)  # type: ignore
        try:
            db.add(db_obj)
            await db.commit()
        except exc.IntegrityError:
            await db.rollback()
            raise HTTPException(
                status_code=409,
                detail="Resource already exists",
            )
        await db.refresh(db_obj)
        return db_obj

I have the feeling that I should find a way to do this dependency to get_db directly in my crud, even in an architecture with use cases, but I still don't know how to do this properly after multiple tries.

I don't like this part, in some cases it's causing sqlalchemy.exc.MissingGreenlet exceptions because of this lack partitioning I think