Dependencies with optional parameters

First check

• I added a very descriptive title to this issue.
• I used the GitHub search to find a similar issue and didn’t find it.
• I searched the FastAPI documentation, with the integrated search.
• I already searched in Google “How to X in FastAPI” and didn’t find any information.
• I already read and followed all the tutorial in the docs and didn’t find an answer.
• I already checked if it is not related to FastAPI but to Pydantic.
• I already checked if it is not related to FastAPI but to Swagger UI.
• I already checked if it is not related to FastAPI but to ReDoc.
• After submitting this, I commit to:
  • Read open issues with questions until I find 2 issues where I can help someone and add a comment to help there.
  • Or, I already hit the “watch” button in this repository to receive notifications and I commit to help at least 2 people that ask questions in the future.
  • Implement a Pull Request for a confirmed bug.

Example

Here’s a self-contained minimal, reproducible, example with my use case:

from fastapi import FastAPI, Depends

app = FastAPI()


def dependency(request: Request, check: bool = True):
    pass


@app.get("/1")
def read_root(t = Depends(dependency, check=False)):
    return {"Hello": "World"}

@app.get("/2")
def read_root(t = Depends(dependency)):
    return {"Hello": "World"}

Description

I searched the docs and didn’t find any reference of this being possible. Could this be done somehow with FastAPI today? Am I missing something?

If it is not possible today, how can this be implemented, I would gladly help with it.

Thanks!

[SirTelemak]

That’s how Depends constructor looks:

class Depends:
    def __init__(self, dependency: Callable = None, *, use_cache: bool = True):

So you can’t pass kwargs here, but there is workaround (but I can’t be sure about how good it will be working):

from fastapi import FastAPI, Depends, Request

app = FastAPI()


def dependency_factory(check: bool = True):
    def dependency(request: Request):
        if check:
            return 1
        return 2
    return dependency


@app.get("/test_overrided")
def read_root(t=Depends(dependency_factory(check=False))):
    return {"Hello": t}

@app.get("/test_default")
def read_root(t=Depends(dependency_factory())):
    return {"Hello": t}

[fgsalomon]

Hi, what about sub-dependencies?

For example say we have a dependency QueryChecker like on the previous examples that has an optional argument and other dependency QueryPrinter that uses the value returned by QueryChecker to do some operation.

How should we approach it?

class QueryChecker:
    def __init__(self, check: str = ""):
        self.check= check

    def __call__(self):
        if check:
            return check
        return "default_value"

class QueryPrinter:
   def __init__(self, check: str = ""):
       self.check = check

  # How can we inject the check argument?
  def __call__(self,  prefix: str = Depends(QueryChecker(check=?))  ):
        print(f"{prefix} Hello")

@app.get("/test_overrided")
def read_root(t=Depends(QueryPrinter(check="foo"))):
    return {"Hello": t}

@app.get("/test_default")
def read_root(t=Depends(QueryPrinter())):
    return {"Hello": t}