List query param type interpreted as body

[wozniakty]

Describe the bug
FastAPI is not correctly auto-interpreting the List typing as a query parameter, and is instead treating it as a body parameter and failing.

To Reproduce
Steps to reproduce the behavior:
Create a file like the following:

from typing import List, Union

from fastapi import FastAPI, Query
from pydantic import BaseModel

app = FastAPI()

class Thing(BaseModel):
    a_id: int
    b_id: int
    c_types: List[str]

@app.get('/a/{a_id}/b/{b_id}/things', response_model=Thing)
async def get_things(a_id: int, b_id: int, c_types: List[str]):
    return Thing(a_id=a_id, b_id=b_id, c_types=c_types)

Expected behavior
pathurl?c_types=something&c_types=somethingelse resolves correctly:
c_types=["something", "somethingelse"]

Actual behavior
FastAPI treats the list typing as a Body declaration (like a pydantic type would be interpreted) and throws this error:

{
    "detail": [
        {
            "loc": [
                "body",
                "c_types"
            ],
            "msg": "field required",
            "type": "value_error.missing"
        }
    ]
}

Environment:

• OS: Windows
• FastAPI Version [e.g. 0.3.0], get it with: 0.29.1
• Python version, get it with: 3.7.3

Additional context
This problem isn't immediately blocking. Adding a = Query() causes the query parameter to be interpreted correctly. However, this forces you to set a default and therefore isn't ok for required parameters (admittedly, few query params are required, but still).

It's also noteworthy that the problem doesn't exist for all kinds of typing syntax. Doing a Union[int, bool] is still treated as a query param (and is validated correctly).

[dmontagu]

@wozniakty
This is discussed in the query parameters and string validation docs:

So, when you need to declare a value as required while using Query, you can use ... as the first argument:

from fastapi import FastAPI, Query

app = FastAPI()

@app.get("/items/")
async def read_items(q: str = Query(..., min_length=3)):
    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
    if q:
        results.update({"q": q})
    return results

If you hadn't seen that ... before: it is a a special single value, it is part of Python and is called "Ellipsis".

So you can just use Query(...) if you want it to be required with no default and no other keyword arguments. (This is also consistent with how you can specify required parameters in pydantic models.)

It goes on to say:

To declare a query parameter with a type of list, like in the example above, you need to explicitly use Query, otherwise it would be interpreted as a request body.

Personally, I more frequently want to handle any kind of list as JSON than as a query parameter, but I think it could make sense to handle lists of primitive types (float, int, str, bool and optional varieties) as query parameters by default. But this would be a breaking change, so unclear whether it's worth it.

[wozniakty]

Ok thanks, I apparently missed some of the nuance in the documentation, my bad.

From my first read through the documentation, I would say that it feels a bit weird for a string list (fairly common query param type) is assumed to be a body. However, I can see why that might be harder to differentiate from a list containing a more complex object.

I'll close this out. Was a bit of a hard to understand nuance but it's obviously not a bug. Thanks!

[tiangolo]

Thanks @dmontagu for your help! 🚀 🍰 🌮

Thanks @wozniakty for reporting back and closing the issue.