Variance of arguments for Generic ABC vs Generic Protocol

[kbehlers]

I am trying to define a Generic base class, but see different type checking behavior when I inherit from abc.ABC versus Protocol. I am trying to figure out if it is really a difference of variance or if it is just an implementation detail of the type checkers. I've tried against pyright and mypy.

Comparing BadProtocolResultWriter and ABCResultWriter, do Generic ABCs just not get typed checked for variance? Or is there something about an ABC that restricts the variance of subclasses?

import abc
from typing import Generic, Protocol, TypedDict, TypeVar



class BaseResult(TypedDict):
    """
    Result
    """


R = TypeVar("R", bound=BaseResult)
R_contra = TypeVar("R_contra", bound=BaseResult, contravariant=True)


class BadProtocolResultWriter(Protocol[R]):
    """
    Type variable "R" used in generic protocol "ProtocolResultWriter" should be contravariant  (reportInvalidTypeVarUse)
    main.py:16: error: Invariant type variable "R" used in protocol where contravariant one is expected  [misc]
    """

    @abc.abstractmethod
    def write(
        self,
        result: R,
    ) -> None:
        """
        Write to destination
        """


class ABCResultWriter(abc.ABC, Generic[R]):
    """
    This type checks just fine, but what is different compared to the Protocol equivalent?
    """

    @abc.abstractmethod
    def write(
        self,
        result: R,
    ) -> None:
        """
        Write to destination
        """

class ContraProtocolResultWriter(Protocol[R_contra]):
    """
    This type checks just fine now that C_contra and R_contra are used
    """

    @abc.abstractmethod
    def write(
        self,
        result: R_contra,
    ) -> None:
        """
        Write to destination
        """


class InvariantProtocolResultWriter(Protocol[R]):
    """
    This type checks just fine, I believe because it forces R to be invariant?
    """

    @abc.abstractmethod
    def write(
        self,
        result: R,
    ) -> R:
        """
        Write to destination
        """

[erictraut]

do Generic ABCs just not get typed checked for variance

Full TypeVar variance consistency is checked only for protocols (as indicated in the typing spec), not for nominal class definitions (including ABCs). Both pyright and mypy do minimal checks for improper usage of covariant and contravariant TypeVars within method parameters and return types, but this isn't the same as full variance consistency checks.

The new TypeVar syntax introduced in PEP 695 eliminates the need to worry about variance consistency because variance is calculated by the type checker based on usage. Pyright has had support for PEP 695 for a long time already, and the next release of mypy will also include support for it.

Code sample in pyright playground

import abc
from typing import Protocol, TypedDict

class BaseResult(TypedDict):
    ...

class BadProtocolResultWriter[R: BaseResult](Protocol):
    @abc.abstractmethod
    def write(self, result: R) -> None:
        ...

class ABCResultWriter[R: BaseResult](abc.ABC):
    @abc.abstractmethod
    def write(self, result: R) -> None:
        ...

class ContraProtocolResultWriter[R: BaseResult](Protocol):
    @abc.abstractmethod
    def write(self, result: R) -> None:
        ...

class InvariantProtocolResultWriter[R: BaseResult](Protocol):
    @abc.abstractmethod
    def write(self, result: R) -> R:
        ...

If you're using pyright or pylance, you can hover over the TypeVar declaration to see the computed variance.

[kbehlers]

Thank you, that answers my question! This was very enlightening, and I appreciate the tips about pyright's PEP 695 support and hovering over the TypeVar declaration!