Nullable Query Parameters

[jurasofish]

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

from typing import Optional

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def home(q: Optional[bool] = True):
    return {"Hello": q}

import uvicorn
uvicorn.run(app, host="127.0.0.1", port=5001)

Description

I have a simple FastAPI route with an Optional[bool] query parameter.
I would like to pass None as the value to the parameter.

I've tried all the following but in every case it is rejected with the messager {"detail":[{"loc":["query","q"],"msg":"value could not be parsed to a boolean","type":"type_error.bool"}]}

• GET /q=
• GET /q
• GET /q=null
• GET /q=none

Is there any way to pass None other that setting it as the default value?

Operating System

macOS

Operating System Details

No response

FastAPI Version

0.73.0

Python Version

Python 3.9.7

Additional Context

No response

[alispa]

Did you try to not mention q at all? Like GET /

[jurasofish]

Yes, in that case it provides the default value of True. So, I could set the default value to None and it would work - but I specifically want the default value to be True.

[alispa]

I must agree that your question makes sense and would make life easier if we could set the query to none instead of avoiding it.

[harunyasar]

This is not a relevant issue directly to the FastAPI again and something that this pydantic doesn't address as you might expect. You can also obviously see in the code block as follow pydantic does not evaluate the values null, Null, none, None as a BOOL_FALSE value. That's why it was raising a validation error.

https://github.com/samuelcolvin/pydantic/blob/d7a8272d7e0c151b0bd43df596be02e0d436ebdf/pydantic/validators.py#L101-L119

If you think that those values were supposed to be treated a bool false value, you could extends the BOOL_FALSE set variable in your application. If you ask me, it would be a hack more than a solution. But, bear in mind that, it will return False instead of the actual value.

from typing import Optional

from fastapi import FastAPI
from pydantic.validators import BOOL_FALSE

BOOL_FALSE.update(["none", "null", ""])

app = FastAPI()


@app.get("/")
def home(q: Optional[bool] = True):
    return {"Hello": q}

[ddanier]

Ran into this once, too.

This is not really an issue with FastAPI nor Pydantic. Query string parameters are always strings, meaning everything you pass here will always end up being a string before being parsed by FastAPI or Pydantic.

You could argue that for boolean values this problem is easy to evade as you only have three possible values here: true, false and null. However this would only be a fix for this particular case and would create some strange inconsistencies inside the way things work here.

Lets' change this to being a str and see what that changes:

@app.get("/")
def home(q: Optional[str] = "foo"):
    return {"Hello": q}

How could we now pass None here?

• /: Must be the default value
• /?q=: Could also be an empty string: ""
• /?q=null: Could also be a string: "null"

So there is no really sane way to distinguish the different cases. Even using some special string like __null__ would not really be unique and may result in errors.

So after running into this myself I figured FastAPI should probably not create a special case for boolean fields - this will lead to confusion and make things harder to unserstand.

My solution was using an enum btw:

class NullBolleanEnum(str, Enum):
    NULL = "null"
    TRUE = "true"
    FALSE = "false"

    def to_python(self) -> Optional[bool]:
        return {"null": None, "true": True, "false": False}.get(self.value)


@app.get("/")
def home(q: NullBolleanEnum = NullBolleanEnum.TRUE):
    return {"Hello": q.to_python()}

(not 100% my solution and just written down here without running it, but should give you an idea)