Since the container ABCs are normal classes, and Protocol cannot subclass normal classes, there's no way to create a protocol that extends the ABCs without explicitly listing out all the methods needed for the collection. e.g., can't do this:

from typing import Iterable, Protocol

class IterableWithMethod(Iterable, Protocol):
    def method(self) -> None: pass

Since the ABCs don't provide any default implementations (I think?), maybe they should just be defined as runtime checkable protocols instead of ABCs?

Thanks for the bug report Anup. I'm mildly confused by what you meant, so please help me here:

I interpreted your request as wanting any type that implements `method` and `__iter__` to be considered a subtype of `IterableWithMethod`. But this already works at runtime and with mypy.

Are you perhaps saying that you want issubclass(Foo, IterableWithMethod) to work?

Yeah, you got the gist of what I meant, though, I guess that was a confusing example since there are apparently protocols for Iterable. But not for many of the other collection ABCs such as Sequence, e.g., the following doesn't work:

from typing import Sequence, Protocol

class SequenceWithMethod(Sequence, Protocol):
    def method(self) -> None: pass

In which case, anything that implements `method`, `__getitem__`, `__len__`, `__contains__`, `__iter__`, `__reversed__`, `index`,  and `count` would be considered a subtype of `SequenceWithMethod`

I suspect this may be intentional. See related issues https://bugs.python.org/issue35190 and https://bugs.python.org/issue23864.

Copying verbatim from what Ivan said in the first issue:

"
The separation may look arbitrary, but the idea is quite simple. Only those classes with few methods support structural checks. Those classes have few independent abstract methods (or even just one method), while in classes with large APIs like `Sequence`, the methods are not logically independent, so you can't say a class is 100% a `Sequence` even if types/signatures of all methods are correct, because e.g. `__contains__()` and `index()` should behave in agreement with `__getitem__()`.
"

The docs need to clarify which ABCs can satisfy isinstance() based solely on hasattr() logic and which ABCs require registration or direct subclassing.

The docs should also explain why the more complex ABCs can't reliably be recognized based on the presence of desired method names.  

One of the original motivating reasons for the ABCs was that the presence of __getitem__ was insufficient for determining whether a class was intended to be a Mapping or a Sequence.  Accordingly, those classes have to subclass from an ABC or register with the ABC in order to declare intent.

New changeset 62fa613f6a6e872723505ee9d56242c31a654a9d by Raymond Hettinger in branch 'main':
bpo-45024 and bpo-23864: Document how interface testing works with the collections ABCs (GH-28218)
https://github.com/python/cpython/commit/62fa613f6a6e872723505ee9d56242c31a654a9d

New changeset 89edd18779e382c5fa7f57722b0b897a907ed2c4 by Miss Islington (bot) in branch '3.10':
bpo-45024 and bpo-23864: Document how interface testing works with the collections ABCs (GH-28218) (GH-28266)
https://github.com/python/cpython/commit/89edd18779e382c5fa7f57722b0b897a907ed2c4

New changeset 9d8a64a7ccebb288094d4e9da66f30d2ada9a973 by Pablo Galindo (Miss Islington (bot)) in branch '3.10':
bpo-45024 and bpo-23864: Document how interface testing works with the collections ABCs (GH-28218) (GH-28266)
https://github.com/python/cpython/commit/9d8a64a7ccebb288094d4e9da66f30d2ada9a973