List[T] validation is not strict enough

[mgu]

with this kind of model :

class Foo(BaseModel):
    items: List[int]

Foo(items='') does not throw any error. Looking at the code, we do not check the list is a list, but we iterate over it and check the elements. Any empty iterable can be used for List[T]

[samuelcolvin]

Not at my computer right now, will reply next week. But there's already an issue discussing this I think.

[samuelcolvin]

There's a long discussion about type casting on vs. raising an error on #45.

I think this is the correct behaviour. Pydantic tries to follow python on what can be cast to what: since '123' can be converted to a list and each element can be converted to an int, it makes sense (at least in my head) that '123' can be converted to [1, 2, 3]. '' is just a special case of this.

[mgu]

For me there is a difference between typing.List and typing.Sequence
'123' is a Sequence, not a List

[samuelcolvin]

I understand that, but pydantic generally relies on "does list(value) work?" and list('123') does work.

The point is that the type hinting is used to define what type the deserialised value will be, not what type input data is.

I won't be changing the libraries standard functionality, but you're welcome to implement StrictList with your own checks.

[mgu]

understood, thx.

[pawelswiecki]

I think this is unexpected:

from typing import List
from pydantic import BaseModel


class User(BaseModel):
    values: List[str]

data = {'values': 'a_string'}

user = User(**data)
assert user.values == ['a', '_', 's', 't', 'r', 'i', 'n', 'g']

Maybe make an exception for strings and don't treat them as sequences, at least in some contexts?

mypy is having the same problem, see python/mypy#5090.

[samuelcolvin]

Ok, for this case I'm happy to accept a change which checks if value is str or bytes and raises a type error. PR welcome.

[Gr1N]

Why we want to check if value is str or bytes only? What about dict?

In [1]: from pydantic import BaseModel

In [2]: from typing import List

In [3]: class Model(BaseModel):
   ...:     foo: List[str]
   ...:

In [4]: m = Model(foo={'key': 'value'})

In [5]: m.foo
Out[5]: ['key']

In [8]:

Maybe better to go with logic similar to StrictStr? Or just check if value not is instance of list and raise exception?

[samuelcolvin]

I guess list or tuple, but nothing else?

[Gr1N]

What about set?

[samuelcolvin]

yes.

[Gr1N]

@samuelcolvin review please #200