Replace trafaret with pydantic

[Dreamsorcerer]

It would probably a good idea to replace trafaret/trafaret-config with pydantic. Trafaret seems somewhat unmaintained and doesn't have any static typing support. Pydantic is likely a better option to use here.

[webknjaz]

I wouldn't mind that, however, trafaret used to be very popular among the community the demos come from. So I'd maybe ping @Arfey / @Deepwalker to see what they think. And if they don't mind/respond in like a week, then it's okay to proceed.

[Deepwalker]

Trafaret is maintained. If I do not accept someones PRs it means that I do not think that they are ready to be merged.

About this examples – I did not write them. And I honestly think that pydantic version will be nice addition, as it is popular in community and has wide adoption.

[Dreamsorcerer]

Thanks. The biggest issue is the support for static typing. I like the overall design of trafaret, but without the option to define things with type annotations or have any type safety from the outputs, that basically rules it out for me. We also heavily support static typing across the aio-libs projects, so it feels a bit weird to recommend a library that can easily result in removing a large chunk of type safety from the user's code.

I'd suggest for now, that we try out pydantic in the polls demo/tutorial to see how it looks (though I intend to look at sqlalchemy first in #161).

[Dreamsorcerer]

To update on this, I'm pretty happy with a custom check() function that allows us to just use standard Python types for type checking. Combined with Pydantic's pipeline API (which is technically still experimental, but shouldn't be difficult to maintain), we have something comparable to trafaret.

The check() function can be defined like this:

@lru_cache
def _get_schema(t, **kwargs):
    config: ConfigDict = {"arbitrary_types_allowed": True, **kwargs}
    if is_typeddict(t) or is_dataclass(t):
        config.update(getattr(t, "__pydantic_config__", {}))
        t = with_config(config)(t)
        return TypeAdapter(t)
    return TypeAdapter(t, config=config)

def check(t, value, **kwargs):
    return _get_schema(t, **kwargs).validate_python(value)

Which can be used like (with a very random, arbitrary example):

def convert_to_int(value: str) -> int:
    return {"foo": 4, "bar": 5}.get(value, 1)

def divide_int(value: int) -> float:
    return value / 3

class MyDict(TypedDict):
    a: Annotated[float, validate_as(str).transform(str.lower).transform(convert_to_int).transform(divide_int)]
    b: int
    d: Annotated[str, validate_as(str).str_upper()]
    e: Annotated[Literal[0, 1], validate_as(str).transform(int).validate_as(...)]

validated_dict = check(MyDict, {"a": "Foo", "b": 42, "d": "foo", "e": "0"})