Adding callable parameters to "Depends" & Adding a new "validator" parameter to "Query"

[alfawal]

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.

Commit to Help

• I commit to help with one of those options 👆

Example Code

def validate_date(date: str):
    try:
        return datetime.strptime(date, "%Y-%m-%d").date
    except ValueError:
        raise HTTPException(
            status_code=400,
            detail="Incorrect date format, should be YYYY-MM-DD",
        )   

@app.get("/endpoint")
async def handler(
    required_date: str = Depends(validate_date),
    optional_date: str | None = None
):
    return "hello"

Description

I wanted to add a validator for the parameters "required_date" and "optional_date" but I must create two functions to handle that because one of them is optional.

Wanted Solution

I would like to see an option in Depends() that let me pass parameters to that callable dependency.

Wanted Code

def validate_date(date: str, is_required: bool = True):
    if date is None:
        if is_required:
            raise HTTPException(400, f"{date=} is required.")
        return None
    try:
        return datetime.strptime(date, "%Y-%m-%d").date
    except ValueError:
        raise HTTPException(
            status_code=400,
            detail="Incorrect date format, should be YYYY-MM-DD",
        )   

@app.get("/endpoint")
async def handler(
    required_date: str = Depends(validate_date),
    optional_date: str | None = Depends(validate_date, parameters={"is_required": False})
):
    return "hello"

Alternatives

Handle input validators in some other cooler way.

Operating System

Windows

Operating System Details

No response

FastAPI Version

0.85.2

Python Version

Python 3.11.0

Additional Context

Another suggestion.
Add "validator" parameter to Query() where it takes a callable to validate that value with the previous suggestion applied (callable parameters).

Sorry in advance if there is an existing approach to what I am trying to do.

[iudeen]

You can use a Pydantic model to validate your Query params. Try that!

Callable to Depends is a good one!

[alfawal]

I did use the pydantic models and validators at the end, but don't we need to apply the suggestion?
I am not sure if its suitable.

[TheJumpyWizard]

@alfawal I personally agree with @iudeen. I think using a Pydantic model to validate the Query params is a sufficient implementation to address your concern. Just to have a bit better of an understanding on your perspective, could you elaborate on why you don't think it's suitable?

[extreme4all]

In the code you provided, the EndpointRequest class is a pydantic model that is used to define the data type, default value, and validation rules for the query parameters in the handler function.

The EndpointRequest class defines two fields, required_date and optional_date. This means that the required_date and optional_date fields will be set to the values of the required_date and optional_date query parameters, respectively, and pydantic will automatically validate the values of these parameters using the validation rules defined in the EndpointRequest class.

The validate_required_date method is a custom validator that is used to validate the values of the required_date and optional_date fields. This method attempts to convert the date string to a datetime.date object using the strptime method, and if the date string is not in the correct format it raises an HTTPException with a status code of 400 and a detailed error message that includes the invalid date value.

The handler function uses the Depends decorator to specify that it depends on an EndpointRequest object, which is automatically constructed by pydantic using the query parameters and validated using the validate_required_date method. This EndpointRequest object is then passed as an argument to the handler function, which returns it in the response.

from pydantic import BaseModel, Field, validator
from datetime import datetime
from fastapi import HTTPException, Query, Depends, FastAPI

app = FastAPI()

class EndpointRequest(BaseModel):
    required_date: str = Query(...) # required
    optional_date: str | None = Query() # optional

    @validator("required_date", "optional_date")
    def validate_required_date(cls, value, field):
        if value is None:
            return value
        try:
            value = datetime.strptime(value, "%Y-%m-%d").date()
        except ValueError:
            raise HTTPException(
                status_code=400,
                detail=f"Incorrect date format, '{value}' should be format YYYY-MM-DD",
            )  
        return value
		
@app.get("/endpoint")
async def handler(request: EndpointRequest = Depends()):
    print(request)
    return request

Source:
#318 (comment)
https://fastapi.tiangolo.com/tutorial/dependencies/classes-as-dependencies/

[extreme4all]

#318

[alfawal]

Thanks a lot, I did it using the pydantic classes as all suggested, although that I would love to see something like a callable param in the Query.

[github-actions]

Assuming the original need was handled, this will be automatically closed now. But feel free to add more comments or create new issues or PRs.