if cls._is_protocol:
            if all(hasattr(instance, attr) and
                    # All *methods* can be blocked by setting them to None.
                    (not callable(getattr(cls, attr, None)) or
                     getattr(instance, attr) is not None)
                    for attr in _get_protocol_attrs(cls)):
                return True
        return super().__instancecheck__(instance)
class Protocol(Generic, metaclass=_ProtocolMeta):
    """Base class for protocol classes.
    Protocol classes are defined as::
        class Proto(Protocol):
            def meth(self) -> int:
                ...
    Such classes are primarily used with static type checkers that recognize
    structural subtyping (static duck-typing).
    For example::
        class C:
            def meth(self) -> int:
                return 0
        def func(x: Proto) -> int:
            return x.meth()
        func(C())  # Passes static type check
    See PEP 544 for details. Protocol classes decorated with
    @typing.runtime_checkable act as simple-minded runtime protocols that check
    only the presence of given attributes, ignoring their type signatures.
    Protocol classes can be generic, they are defined as::
        class GenProto(Protocol[T]):
            def meth(self) -> T:
                ...
    """
    __slots__ = ()
    _is_protocol = True
    _is_runtime_protocol = False
    def __init_subclass__(cls, *args, **kwargs):
        super().__init_subclass__(*args, **kwargs)
        # Determine if this is a protocol or a concrete subclass.
        if not cls.__dict__.get('_is_protocol', False):
            cls._is_protocol = any(b is Protocol for b in cls.__bases__)