TypeVar bound or constrained to bool, diverging behavior with mypy

[Viicos]

Following https://discuss.python.org/t/41483 where I couldn't find a viable solution (it would require typing features not yet implemented), I'm trying to find an alternative solution. TL;DR, Field is generic over the __set__ and __get__ type, and both can be None if null=True is used when instantiating the class.

The alternative I'm exploring is adding an extra type variable _NullT, bound to bool. What I did at first was:

from typing_extensions import TypeVar

_NullT = TypeVar("_NullT", bound=bool, default=Literal[False])

class Field(Generic[_ST, _GT, _NullT]):
    def __init__(self, null: _NullT = False):
        ...

class IntField(Field[int | float, int, _NullT]):
    pass

f = IntField(null=True)

In this example, f is inferred as IntField[bool], which makes sense! The type of True is bool. So I've tried switching to this type variable instead, using constraints:

_NullT = TypeVar("_NullT", Literal[False], Literal[True], default=Literal[False])

As I understand it, solving this type variable would result in either Literal[False] or Literal[True] (which can be considered as types?). However, pyright still infers f as being IntField[bool].

Code sample in pyright playground

from typing import Any, Literal, Generic, overload
from typing_extensions import TypeVar

# __set__ value type
_ST = TypeVar("_ST", contravariant=True)
# __get__ return type
_GT = TypeVar("_GT", covariant=True)

_NullT = TypeVar("_NullT", Literal[True], Literal[False], default=Literal[False])
#_NullT = TypeVar("_NullT", bound=bool, default=Literal[False])

class Field(Generic[_ST, _GT, _NullT]):
    def __init__(self, null: _NullT = False):
        ...

    # Focusing on __get__ for now:
    @overload
    def __get__(self: Field[_ST, _GT, Literal[True]], instance: Model, owner: Any) -> _GT | None: ...
    @overload
    def __get__(self: Field[_ST, _GT, Literal[False]], instance: Model, owner: Any) -> _GT: ...
    


class IntField(Field[int | float, int, _NullT]):
    pass


class Model:

    f = IntField(null=True)

reveal_type(Model().f)

Now something really weird is, with either the first or second _NullT type variable commented out, I always get IntField[bool], but if you leave both uncommented, f is inferred as IntField[Literal[False]] (ideally it should be IntField[Literal[True]], but it doesn't seem to be taking into account the passed value of null). I believe this is because pyright gets confused with the redefinition of _NullT.

---

With mypy, I get something almost working, although there are still some weird errors happening. f is correctly inferred as IntField[Literal[True/False]] (depending on the initialized null value), however it does not seem to pick the right overload.

mypy playground

[Viicos]

python/mypy#10207 (comment) gives a nice solution, but it would be even better if inferred without any __init__ overloads. (And I can't make it work with subclasses when other type variables are in play: playground)

[erictraut]

Looks like a bug in pyright. You're doing something very unusual here — using literal types as value constraints. Pyright's constraint solver includes some heuristics about when to retain literals and when to widen the type to non-literals. I'm guessing that those heuristics are failing in this case. Please file a bug, and I'll investigate further.

[Viicos]

using literal types as value constraints.

Indeed, this seems to be the only way to avoid defining overloads (and it also plays really nice with type var defaults). Thanks for the answer, I've opened an issue.