Support for Depends() about fastapi-events

[breathingcyborg]

Hi @melvinkcx. We are facing the same issue. The event handlers often need to have access to other services, like in this example where we want to inject sequelize session using fastapi di system.

@local_handler.register(event_name='dummy-event')
async def dummy_event_handler(event : Event, db : Session = Depends(get_db)):
    # Do something with the db
    return

[melvinkcx]

Thank you for your patience. I just released a new version (link) that includes the support of dependencies in local handlers. Feel free to report any potential issues 🙏

[melvinkcx]

@unkindypie @breathingcyborg Thanks for raising the request. I'm looking into the feasibility of supporting DI in LocalHandler without introducing any breaking changes. If you already have an idea or a workaround you're currently using, feel free to share them =)

[breathingcyborg]

@melvinkcx Thanks for looking into the issue.

As a workaround we created a custom decorator.

import inspect
from typing import Callable
from fastapi.dependencies.utils import get_dependant, solve_dependencies
from fastapi import Request
from contextlib import AsyncExitStack
from fastapi_events.typing import Event
from pydantic import ValidationError

def event_handler(path: str):
    """ decorator to enable fastapi dependency injection
    for fastapi_events event handlers

    Usage Example:
    @local_handler.register(event_name='event.test')
    @event_handler(path='handlers.event.test.handle_test_event')
    def handle_test_event(event: Optional[Event] = None, db: Session = Depends(get_db)):
        # use db here
    """
    def wrap(func: Callable):
        async def wrap_inner(event: Event):
            async with AsyncExitStack() as cm:
                request = Request({
                    "type": "http",
                    "headers": [],
                    "query_string": "",
                    "fastapi_astack": cm
                })
                dependant = get_dependant(
                    path=path,
                    call=func
                )
                values, errors, _1, _2, _3 = await solve_dependencies(
                    request=request,
                    dependant=dependant
                )
                values['event'] = event
                if errors:
                    raise ValidationError(errors, None)
                if inspect.iscoroutinefunction(dependant.call):
                    result = await dependant.call(**values)
                else:
                    result = dependant.call(**values)
                return result
        return wrap_inner
    return wrap

And we use it like this

@local_handler.register(event_name='event.test')
@event_handler(path='handlers.event.test.handle_test_event')
def handle_test_event(event: Optional[Event] = None, db: Session = Depends(get_db)):
    # use db here
    pass

This is very hacky

• event must be the first argument and its value must be set to None
• and because other things like dummy request and asyncexitstack.
• also the path must be unique (not sure about this but I've read that fastapi caches dependencies)

[breathingcyborg]

Thanks for your help. Although support for yield is not blocking for us, but it would be really helpful.

[melvinkcx]

Hi @unkindypie, I'm trying to understand the missing feature you're looking for here. Do you mean the events injected within the injected services are not working?
Do you mind providing a simple example of how you'd use it if it supports Depends()? Thank you =)

[melvinkcx]

Thanks for sharing your workaround. I'm working on a PR to support Depends() in local event handlers.

However, for the first version, there will be some limitations:

• Sub-dependencies will be supported
• Dependency caching is not supported
• Dependency override is not supported
• Dependencies using a generator (yield) are not supported (yet)

I figured the last point might be a blocker to some of you. Let me know if that's the case.

[unkindypie]

Thank you @melvinkcx !