Nested injected services and factory SqlAlchemy Session

[nerlijman]

I have configured a simple fastapi app with 2 services. Dummy and Dummy2. Dummy calls Dummy2 and they all run in same transaction.

class Database:
    def __init__(self, db_url: str):
        self.db_url = db_url
        self.engine = create_engine(self.db_url)
        self.orm_session = scoped_session(
            sessionmaker(autocommit=False,
                         autoflush=False, bind=self.engine))
    def session(self):
        return self.orm_session()

import os
from dependency_injector import containers, providers

from app.db import Database
from app.services.dummy import DummyService
from app.services.dummy2 import Dummy2Service

class Container(containers.DeclarativeContainer):
    db_url = os.getenv("URL")

    db = providers.Singleton(Database, db_url=db_url)
    db_session = providers.ContextLocalSingleton(db.provided.session.call())

    dummy2_service = providers.Factory(
        Dummy2Service,
        session=db_session)
        
    dummy_service = providers.Factory(
        DummyService,
        dummy2_service = dummy2_service,
        session = db_session)

class DummyService:

    def __init__(
        self, 
        dummy2_service: Dummy2Service, 
        session: orm.Session):

        self.dummy2_service = dummy2_service
        self.session = session

    def create_dummy(
            self, 
            name: str
        ) -> models.Dummy:
        
        try:
            dummy = models.Dummy(
                name=name,
            )
            self.session.add(dummy)
            self.session.flush()
            self.session.refresh(dummy)

            # call service 2
            dummy2 = self.dummy2_service.create_dummy(name + "_second")

            self.session.commit()
        except Exception as e:
            print('Session rollback because of exception: %s', e)
            self.session.rollback()
        finally:
            self.session.close()
            
        return dummy2

from app import models
from sqlalchemy import orm

class Dummy2Service:

    def __init__(self, session: orm.Session):
        self.session = session

    def create_dummy(self, name: str) -> models.Dummy:
            dummy = models.Dummy(
                name=name,
            )
            
            self.session.add(dummy)
            self.session.flush()
            self.session.refresh(dummy)

            return dummy

Instead of using in Database

def session(self):
        return self.orm_session()

I would like to use a generator function to avoid doing commit or rollback in every parent service, but I cannot make it work with dependency-injector. And use this:

     @contextmanager
    def session(self):
        s: Session = self.orm_session()
        try:
            yield s
            s.commit()
        except Exception as e:
            s.rollback()
        finally:
            s.close()

I am dealing with this line in Container

db_session = providers.ContextLocalSingleton(db.provided.session.call())

But nothing seems to work. (without generator function works fine)

Any suggestions?