I'm sure Pydantic is working correctly, and my interpretation of what's going on is evidently wrong. However that doesn't change the issue: Params should not be receiving the empty list as default because there is an ids query parameter whose value should be supplied instead. If I change ids in the model to str, then it receives that value. So something (fastapi, I assume) is deciding to not supply the ids string as the parameter value when ids is a list, probably because it can't implicitly convert the type, but this prevents me from using the validator to convert it to the correct type - as is done when I instantiate the model manually.

Thanks for reminding me about the empty list default, I'm still new to python so forget about these things.

Update: you mentioned the request body being empty, which made me wonder if it was actually trying to get the value from the body, and of course it wouldn't be there, in which case the default would be used - sure enough that's what was happening. I changed the model to:

ids: list[str] = Field(Query())

And now it's actually getting the value from the query parameters, resulting in ids of ["1,2,3"].

It's still not quite right however - I should be getting "1,2,3" not ["1,2,3"]. Evidently there is some preprocessing going on before the values are supplied to my model, which is a problem for me because if ids is typed as list[int] (which it is in my actual use case) then I get a 422 error with a message about it not being a valid integer (validator was changed to return list of int). But when constructing manually, with ids="1,2,3", it works fine because the validator converts them to a list of int, and there is nothing checking and failing beforehand.

Sorry @michaelspori but there are alot of python/fastapi/pydantic concepts that you are missing here and it is very tough to explain to you all the stuff you are missing via github discussions. The reason why you get an error when you pass in "1,2,3" to a type of list[int] is because the validator just splits the string into a list of strings ['1', '2', '3'] which is of type list[str] not list[int]. You can fix it by casting each element to int inside your validator using this

@validator("ids", pre=True)
def split_string(cls, val):
    print("validator: received", val.__repr__())
    return [int(x) for x in string.split(",")] if isinstance(val, str) else ["boo"]

Another sidenote:

# this is not the correct way to define a query parameter
ids: list[str] = Field(Query())
# Instead use this
ids: list[str] = Query(default_factory=list)

No, I understand that. I appreciate your help. However I still feel something is being lost in translation here. Maybe on my side. I didn't post the code but I mentioned that I'd updated the validator to return a list of ints. I did basically what you did in the validator, and I also tried hardcoding it to just return something like [1,2] and completely ignore the input. In either case, I got an error saying it's not a valid integer.

To be super clear: If I run this code:

from fastapi import Depends, FastAPI, Request, Query
from pydantic import BaseModel, validator, Field


class Params(BaseModel):
    ids: list[int] = Field(Query(default_factory=list))

    @validator("ids", pre=True)
    def split_string(cls, val):
        print("validator: received", val.__repr__())
        return [4, 5]


app = FastAPI()


@app.get("/test")
def test(params: Params = Depends()):
    print(params)
    return params

And hit it with this:

curl http://127.0.0.1:8000/test?ids=1,2,3

I get this error:

{"detail":[{"loc":["query","ids",0],"msg":"value is not a valid integer","type":"type_error.integer"}]}

And nothing is printed from the validator.

If I change the model to ids: list[int] = Query(default_factory=list) then the validator functions receives None.
If I change the model to ids: list[str] = Query(default_factory=list) then the validator function receives None.
If I change the model to ids: list[str] = Field(Query(default_factory=list)) then the validator function receives ['1,2,3'].

So none of those seem right. Am I doing something wrong? What I expect is the same behaviour as when I construct the model manually, i.e. the validator receives the "1,2,3" string and spits out a list of ints.

If it's too much of a bother, don't worry, I have a workaround, but it's bothering me that I can't just get it working with validators as I think it should.

Ok now it is much clearer!

# For some reason, the only was i found to read  a Query parameter as a list from a pydantic model is what you have done 
ids: list[str] = Field(Query(default_factory=list))
# however this is weird because a query parameter should not take in a list, instead a string as you have done
# or else swagger doc will be very weird and ask to input a list of ids like this `ids=1&ids=2&ids=3` which works but it looks very bad imo.

# I do not know why this does not read from query but instead expects ids to be in the request `body`!
ids: list[int] = Query(default_factory=list)
# however this works as expected
ids: str = Query()

# so i guess if it was a list, it will force it into the body of the api

I am not sure if it is a bug in pydantic or fastapi. @Kludex can you please investigate this behavior?

Not only that but @michaelspori you are right! it seems like the fastapi validates the query param type before executing the validator. This highlights the fact that validators work before or after assignment, but fastapi will validate the input even before creating the model.

I did not, and still have the same issue as well. I typically create a model for input parameters, so what I do as a workaround is type the value as something that fastapi won't reject (for example, str), then create a private attribute of the actual type I want, a public property for that private attribute, and a field or model validator that performs the actual parsing from the fastapi-approved type to the type I want and sets the property. I then use that property throughout the codebase when interacting with the model, rather than the field for the actual value received.

For example:

from pydantic import BaseModel, model_validator, PrivateAttr

class SampleParams(BaseModel):
    ids: str | None = None
    _entity_ids: list[int] | None = PrivateAttr(default=None)

    @property
    def entity_ids(self):
        return self._entity_ids
    
    @entity_ids.setter
    def entity_ids(self, val: list[int] | None):
        self._entity_ids = val
    
    @model_validator
    def validate_model(self):
        if self.ids:
            ids = [x.strip() for x in self.ids.split(",")]
            self.entity_ids = [int(x) for x in ids if x]

Then I only ever access entity_ids rather than ids.

Got it, thanks for the example @michaelspori! This is essentially what I ended up doing as well (though TIL PrivateAttr, I couldn't get a field with a leading underscore to work with Pydantic otherwise). A little frustrating that FastAPI doesn't seem to respect Pydantic validation, but 🤷