Parameter converter of the field() function for @dataclass_transform

[luwqz1]

Hello, i have a question about of the converter parameter of the field() function for the dataclass_transform decorator. Im not sure if this is a bug or intended behavior, so im asking here. I have example:

from __future__ import annotations

import typing

T = typing.TypeVar("T")


def field(*, converter: typing.Callable[[typing.Any], typing.Any]) -> typing.Any: ...


class From(typing.Generic[T]):
    def __new__(cls, _: T, /) -> typing.Any: ...


class Field(typing.Generic[T]):
    if typing.TYPE_CHECKING:
        @typing.overload
        def __get__(self, instance: None, owner: type[Model]) -> T: ...

        @typing.overload
        def __get__(self, instance: Model, owner: type[Model]) -> T: ...

        def __get__(
            self,
            instance: Model | None,
            owner: type[Model],
        ) -> Field[T] | T: ...


@typing.dataclass_transform(field_specifiers=(field,))
class Model: ...


class User1(Model):
    id: int
    is_bot: bool
    first_name: str
    last_name: Field[str] = field(converter=From[str])


user1 = User1(...)
typing.reveal_type(user1.last_name)  # Type of "user1.last_name" is "Field[str]"


class User2(Model):
    id: int
    is_bot: bool
    first_name: str
    last_name: Field[str]


user2 = User2(...)
typing.reveal_type(user2.last_name)  # Type of "user2.last_name" is "str"

So, in this code there is a Field class with an implemented __get__ method that returns the type specified in the generic. I also know that Pyright generates for fields type __converterDescriptor_fieldname where converter is specified in the field function. Could this be related to why my descriptor in the Field class is not working in the example where I used it in the last_name field in the User1 class? Or could there be some other reasons? I would appreciate it if you could explain!

[erictraut]

Please refer to this part of the typing spec for details about how type checkers handle the converter parameter for field specifiers.

The type annotation that you use for a dataclass attribute with a converter should be the type returned by the converter. I can't tell from your code sample what type that is in this case because the From constructor is annotated to return Any, and no implementation was provided.

If you annotate last_name with a Field[str], a type checker will assume that the converter is returning a Field[str] object. That wouldn't make sense here because Field is a descriptor object, but the __get__ method of a descriptor object isn't invoked if the descriptor object is an instance variable.

[luwqz1]

I use the From class as a hack to change the type in the __init__, thats the __new__ method has return annotation type Any. Do you mean that in this case the descriptor method is not called, so the type will be Field[str]?

[erictraut]

Here's what I mean when I say that the __get__ method of a descriptor object isn't invoked if the descriptor object is an instance variable.

class Desc:
    def __get__(self, instance, owner):
        return 1

class Foo:
    # Assign a descriptor object to a class variable
    a = Desc()

    def __init__(self):
        # Assign a descriptor object to an instance variable
        self.b = Desc()

print(Foo().a)  # prints 1
print(Foo().b)  # prints Desc

What is the type of the object that your converter function returns? That's the type that should appear in the annotation for last_name attribute.

[luwqz1]

Thank you for such a simple yet clear example. Additionally, i decided to check by specifying the type typing.ClassVar[Field[str]] = field(converter=From[str]), and indeed when accessing the field, the type is str. I will mark your reply as answer to the question.