Referencing self type in a dataclass/pydantic model

[povilasb]

I want to do some seemingly simple typing but have hard time expressing it in Python.
Say I have this data class:

from pydantic import BaseModel

class Item(BaseModel):
    value: int

Now say I have a builder for any subtype of Item:

_I = TypeVar("_I", bound="Item")


class Builder(Generic[_I]):
    def __init__(self, val: int) -> None:
        self._val = val

    def build(self, item_t: Type[_I]) -> _I:
        return item_t(value=self._val)
        
Builder(3).build(Item)

And here's the typing problem I've faced so far.
I want to define a builder as a class variable for the item itself that will be built:

default_builder = Builder["Item"](0)


class Item(BaseModel):
    value: int
    builder: ClassVar[Builder["Item"]] = default_builder

reveal_type(Item.builder) correctly identifies that the type is Builder[Item].
But if I have other items inheriting from Item:

class Subitem(Item):
    builder = Builder["Subitem"](5)

reveal_type(SubItem.builder)

The inferred type is still Builder["Item"].

Is there a way to express that the generic type variable is always the type of the class containing the builder?

class Item(BaseModel):
    builder: ClassVar[Builder[SelfClassType]] = default_builder

Then ideally this would make pyright infer the type for subitems:

class Subitem(Item):
    builder = Builder()   # Expected type is Builder[Subitem]

Since me and my colleague didn't find any ways to express this we did a bunch of experiments with metaclasses hoping to hint pyright about the constructed class (i.e. subtypes of Item) that resulted in these issues:

• Pyright reports incompatible types in some circumstances when inheriting from a class implementing Generic #1796
• Pyright says type is the name of the variable rather than its actual type #1801

But maybe we're missing some typing/pyright features here? 🤔

Thank you :)

[erictraut]

I kind of understand what you're trying to do here, but the relationships between your various classes is really contorted. You are effectively trying to override the constructor for an Item class by providing another class Builder that's responsible for constructing the Item subclass. It's also really fragile code because Builder makes assumptions about subclasses of Item that cannot be enforced by a type checker. For example, if you were to add a new field to SubItem that doesn't have a default value, the constructor call in the build method would fail at runtime because you're providing only one argument. I would personally look for a different approach here.

If you want to stick to your current formulation, here are some thoughts...

When you assign the value of a class or instance variable without providing a type declaration, pyright assumes that you want to use the type declaration from the base class. In your case, SubItem is assigning a value to class variable builder, but it provides no type declaration for builder, so pyright assumes that you want its type to be Builder[Item], as inherited from Item. If you want the subclass's class variable to have a narrower type, you need to make that explicit with a type annotation in the subclass:

class SubItem(Item):
    builder: ClassVar["Builder[SubItem]"] = Builder["SubItem"](5)

Another approach is to make the builder class variable a Builder[Any] and then use a class method to provide some level of type safety.

class Item(BaseModel):
    value: int

    builder: ClassVar[Builder[Any]] = default_builder

    @classmethod
    def build(cls: Type[_I]) -> _I:
        return cls.builder.build(cls)

[povilasb]

Thank you.
Wanted to make sure there is no related typing feature I wasn't aware of :)