Disable method calls for generic class specialization

[uriyyo]

Hi,

Is it possible to have typing errors when calling a generic class method with a specific specialized type?

It's possible to enable a method for a specific type, but I want to disable it.

Example (enable method only for str generic specialization)

from __future__ import annotations

from dataclasses import dataclass
from typing import Generic, TypeVar, TYPE_CHECKING, Type, List

T = TypeVar("T")


@dataclass
class Op(Generic[T]):
    val: T
    op: str


T_co = TypeVar("T_co", covariant=True)


@dataclass
class Field(Generic[T_co]):
    type: Type[T_co]

    if TYPE_CHECKING:
        def like(self: Field[str], val: str, /) -> Op[str]:
            pass


f_str = Field(str)
f_str.like("a")

f_int = Field(int)
f_int.like("a")

f_seq = Field(List[int])
f_seq.like("a")

temp_1.py:31:1: error: Invalid self argument "Field[int]" to attribute function "like" with type "Callable[[Field[str], str], Op[str]]"  [misc]
temp_1.py:34:1: error: Invalid self argument "Field[List[int]]" to attribute function "like" with type "Callable[[Field[str], str], Op[str]]"  [misc]
Found 2 errors in 1 file (checked 1 source file)

My current workaround (return None for specific generic specializations):

from __future__ import annotations

from dataclasses import dataclass
from typing import Generic, TypeVar, TYPE_CHECKING, Type, overload, Any, Optional, Sequence, List

from typing_extensions import reveal_type

T = TypeVar("T")


@dataclass
class Op(Generic[T]):
    val: T
    op: str


T_co = TypeVar("T_co", covariant=True)
TArg = TypeVar("TArg")


@dataclass
class Field(Generic[T_co]):
    type: Type[T_co]

    if TYPE_CHECKING:
        @overload
        def lt(self: Field[str], val: Any, /) -> None:  # type: ignore[misc]
            pass

        @overload
        def lt(self: Field[Sequence[T]], val: Any, /) -> None:  # type: ignore[misc]
            pass

        @overload
        def lt(self: Field[TArg], val: TArg, /) -> Op[TArg]:
            pass

        def lt(self, val: Any, /) -> Optional[Any]:
            pass


f_int = Field(int)
reveal_type(f_int.lt(1))

f_str = Field(str)
reveal_type(f_str.lt("a"))

f_seq = Field(List[int])
reveal_type(f_seq.lt([1]))

temp_2.py:43:13: note: Revealed type is "temp_2.Op[builtins.int]"
temp_2.py:46:13: note: Revealed type is "None"
temp_2.py:49:13: note: Revealed type is "None"
Success: no issues found in 1 source file

But I would like to get typing error instead of None as return type.

[Akuli]

This is basically a use case for #1043.

[erictraut]

What is it about str and Sequence[T] that they don't work with your generic class implementation? Or more importantly, what is it about other types that allow them to work with your implementation? If you can answer that question, you should be able to describe it using a protocol and use that protocol as an upper bound for T_co. That way, a type checker would generate an error for any type that doesn't meet the requirements of the protocol.

[Daverball]

The way I'm reading the original question I'm guessing that he's trying to implement something like an SQLAlchemy ORM or pandas DataFrame where you can use operators to build expressions that can then later be compiled/evaluated inside a query such as Foo.a < 20, but some of the operations are only valid for a subset of the possible data types of Field.

One possible solution would be to create subclasses with those specific restrictions and add overloads to __init__ to retrieve the correct subclass. The disadvantage of that approach would be that those operations would then not be available on the base class, so Field[Any] would probably end up being annoying to use, so you would still be better of with something like a type_error decorator to mark the operations that become invalid once you specialize the Field. It might however be possible to provide an upper bound for TArg instead.