How to do the most fundamental duck-typing with Protocols?

[randolf-scholz]

How does one implement the most essential duck typing with typing.Protocol? Specifically, how to write a Protocol-class such that an instance obj of a (non-protocol) subtype has to satisfy:

1. hasattr(obj, name)
2. isinstance(obj.name, T)

How the subclass manages to satisfy these conditions is irrelevant. Python offers multiple builtin-options: basic attributes, ClassVar, @property, @cached_property. Here, we do not care if it is mutable or not, all we want is that obj.name gives a T. However, these are considered mutually incompatible by different type checkers, in fact, I made a compatibility chart (mypy 1.7.1 / pyright 1.1.339):

Source

from abc import abstractmethod
from functools import cached_property
from typing import ClassVar, Protocol


class ParentAttribute(Protocol):
    foo: int


class ParentClassVar(Protocol):
    foo: ClassVar[int]


class ParentProperty(Protocol):
    @property
    @abstractmethod
    def foo(self) -> int: ...


class ParentCachedProperty(Protocol):
    @cached_property
    @abstractmethod
    def foo(self) -> int: ...


class Attribute_Attribute(ParentAttribute):
    foo: int = 0


class Attribute_ClassVar(ParentAttribute):
    foo: ClassVar[int] = 0


class Attribute_Property(ParentAttribute):
    @property
    def foo(self) -> int:
        return 0


class Attribute_CachedProperty(ParentAttribute):
    @cached_property
    def foo(self) -> int:
        return 0


class ClassVar_Attribute(ParentClassVar):
    foo: int = 0


class ClassVar_ClassVar(ParentClassVar):
    foo: ClassVar[int] = 0


class ClassVar_Property(ParentClassVar):
    @property
    def foo(self) -> int:
        return 0


class ClassVar_CachedProperty(ParentClassVar):
    @cached_property
    def foo(self) -> int:
        return 0


class Property_Attribute(ParentProperty):
    foo: int = 0


class Property_ClassVar(ParentProperty):
    foo: ClassVar[int] = 0


class Property_Property(ParentProperty):
    @property
    def foo(self) -> int:
        return 0


class Property_CachedProperty(ParentProperty):
    @cached_property
    def foo(self) -> int:
        return 0


class CachedProperty_Attribute(ParentCachedProperty):
    foo: int = 0


class CachedProperty_ClassVar(ParentCachedProperty):
    foo: ClassVar[int] = 0


class CachedProperty_Property(ParentCachedProperty):
    @property
    def foo(self) -> int:
        return 0


class CachedProperty_CachedProperty(ParentCachedProperty):
    @cached_property
    def foo(self) -> int:
        return 0

subclass\parent	attribute	classvar	property	cached_property
attribute	✅,✅	❌,❌	✅,❌	✅,❌
classvar	❌,❌	✅,✅	✅,❌	✅,❌
property	❌,❌	❌,❌	✅,✅	✅,❌
cached_property	❌,❌	❌,❌	✅,❌	✅,✅

EDIT: Fixed wrong data entry in table.

Question: How to write a Protocol that is essentially equivalent to statically asserting (1) and (2), and nothing more?

It seems not even a workaround like the following is not feasible, since property is not generic.

name: T | ClassVar[T] | property[T] | cached_property[T]