Using Depends() in other functions, outside the endpoint path operation!

[vjanz]

Hey community,

I don't know if this feature is available, but I want to ask if I can use dependencies outside endpoint path decorators and functions..

I have this repository, when inside some function on that, I need another repository function to perform the full task.
What I want to do is to inject that as a dependency, and not to create an instance of it, since that is best way to do that here in python, because I come from background of Java and I always used to initialize a instance of that Class.

So basically..I have a function to get an instance of SynonymCrud()

def get_synonym_crud():
    return synonym_crud

the function in to create a word, in #word_crud.py

def create_word(self, word: WordCreate, dictionary_id: int, synonym: List[SynonymCreate],synonym_crud:SynonymCrud = Depends(get_synonym_crud)):
w_dict = word.dict()
w_dict.update({"word": word.word.lower()})
db_word = Word(**w_dict, dictionary_id=dictionary_id)
self.database.add(db_word)
self.database.commit()
self.database.refresh(db_word)
synonyms_to_create = synonym_crud.create_many_synonyms(synonym, db_word.id)
return db_word

Here I tried to inject: synonym_crud:SynonymCrud = Depends(get_synonym_crud),
but when I try to execute this on the endpoint I get an error, that says:
AttributeError: 'Depends' object has no attribute 'create_many_synonyms', even tho I got this function in the SynonymRepository.

This is not the only case, even when I try to inject anything else like database dependency outside the endpoint I get like: AttributeError: 'Depends' object has no attribute 'query' or something similar.

endpoint..

@router.post("/tests/words/", response_model=Word)
def create_word(request: Request, word: WordCreate, dictionary_id: int,
synonym: List[SynonymCreate],
logger: logging.Logger = Depends(get_logger_test),
word_repo: WordCrud = Depends(get_word_crud),
current_user: User = Depends(get_curr_active_superuser)):
word_to_create = word_repo.find_by_name(word.word)
if word_to_create:
raise HTTPException(status_code=400, detail="Word already exists")
word_created = word_repo.create_word(word, dictionary_id, synonym)

    return word_created

Here the other dependency word_repo, works without any error, but when I try to inject anything outside the endpoint functions( like the example with synonym).

Is this possible, or what am I doing wrong?
Thank you in advance

[tiangolo]

Hey @vjanz , if your code runs outside of FastAPI you're better using explicit objects.

Dependencies are, in the end, a way to get or process data based on a request. But if your code is not related to a request (not in a FastAPI app) then there's no advantage and it would just add complexity to your code.

On the other side, a dependency function is in the end, just a function. So, if you pass all the arguments with the correct values instead of letting it get the default value returned by Depends() you can just use it directly as a normal function.

Anyway, I assume you solved your problem, so, thanks for closing the issue 👍

[rfleschenberg]

One situation where this would be useful is if you have code paths outside of router functions (the equivalent of Django management commands, basically) that you are calling from tests, and you want to share your dependency_overrides with them.

I guess I can use monkey-patching / unittest.mock instead, but having dependency_overrides "just work" would be nice.

[m4bwav]

A good dependency injection system can have value outside of a web request.

[unkindypie]

A good dependency injection system can have value outside of a web request.

Totally agree. I have a dozen services built on top of FastAPI's DI system and I simply can't use them without manually setting up all of their dependencies if I would like to run a service from a CRON task which isn't a part of FastAPI app.

[couteau]

Agree that when you have lots of dependencies and sub dependencies, setting them up manually is not ideal. I came up with a quick and dirty solution to this that works for my use case (basically, using the same set of services for command line scripts as for api endpoints). Not sure if it will work for all use cases -- e.g., I'm not sure what would happen if any dependencies depended on query parameters, path parameters, headers, or cookies.

It looks like this:

import argparse
import inspect
from abc import abstractmethod
from contextlib import AsyncExitStack
from typing import Callable

from fastapi import Request
from fastapi.dependencies.models import Dependant
from fastapi.dependencies.utils import (
    get_dependant,
    solve_dependencies
)
from pydantic import ValidationError


class Command:
    def __init__(self, name: str | None = None, namespace=None):
        self.name = name or self.__class__.__name__
        self.parser = self.make_parser()
        self.args = self.parser.parse_args(namespace=namespace)

    # override to add command-line arguments
    def make_parser(self) -> argparse.ArgumentParser:
        return argparse.ArgumentParser(prog=self.name)

    @abstractmethod
    async def command(self):
        pass

    async def solve_command(self, request: Request, dependant: Dependant):
        values, errors, _1, _2, _3 = await solve_dependencies(request=request, dependant=dependant)
        if errors:
            raise ValidationError(errors, None)
        if inspect.iscoroutinefunction(dependant.call):
            result = await dependant.call(**values)
        else:
            result = dependant.call(**values)

        return result

    async def run_command(self, command: Callable):
        async with AsyncExitStack() as cm:
            request = Request({
                "type": "http",
                "headers": [],
                "query_string": "",
                "fastapi_astack": cm
            })

            dependant = get_dependant(
                path=f"command:{self.name}",
                call=command
            )

            return await self.solve_command(request, dependant)

    async def run(self):
        return await self.run_command(self.command)

A subclass can override the command method and add/use any top-level dependencies. The dependencies will then be resolved and the command method executed when the script calls the run method. Or an arbitrary function with dependencies can be invoked using the run_command method.

E.g.,

import asyncio
from fastapi import Depends
from app.services import MyService
from app.command import Command

class MyCommand(Command):
    async def command(self, service: MyService = Depends()):
        service.DoSomething()

def main():
    command = MyCommand("my-command")
    asyncio.run(command.run())

if __name__ == "__main__":
    main()

or

import asyncio
from fastapi import Depends
from app.services import MyService
from app.command import Command

async def command(service: MyService = Depends()):
    service.DoSomething()

def main():
    command = Command("my-command")
    asyncio.run(command.run_command(command))

if __name__ == "__main__":
    main()