Quick and small fix.

os.PathLike.__subclasshook__ does not check if cls is PathLike as abstract classes should.

This in turn causes this bug:

    class A(PathLike):
        pass

    class B:
        def __fspath__(self):
            pass

assert issubclass(B, A)

I will fix the bug later today and push a patch over to python/cpython on GitHub.

I can't reproduce in Python 3.8.0:

>>> import os
>>> class A(os.PathLike): pass
...
>>> class B:
...     def __fspath__(self): pass
...
>>> issubclass(B, A)
True

Did you check against an older version of Python?

Hey Brett, that's exactly the bug. It's supposed to be False ofc.

On Thu, Nov 21, 2019, 9:45 PM Brett Cannon <report@bugs.python.org> wrote:

Brett Cannon <brett@python.org> added the comment:

I can't reproduce in Python 3.8.0:

>>> import os
>>> class A(os.PathLike): pass
...
>>> class B:
... def __fspath__(self): pass
...
>>> issubclass(B, A)
True

Did you check against an older version of Python?

----------
resolution: -> not a bug
stage: -> resolved
status: open -> closed

---

Python tracker <report@bugs.python.org>
<https://bugs.python.org/issue38878\>

---

Ah, your assert call threw me since it does succeed so it isn't acting as a test case.

Done.

On Fri, Nov 22, 2019, 12:23 PM Bar Harel <report@bugs.python.org> wrote:

Change by Bar Harel <bzvi7919@gmail.com>:

----------
keywords: +patch
pull_requests: +16820
stage: resolved -> patch review
pull_request: #17336

---

Python tracker <report@bugs.python.org>
<https://bugs.python.org/issue38878\>

---

I just realized one problem with this is it explicitly requires subclassing the ABC while os.PathLike is supposed to represent a protocol (before typing.Protocol was a thing).

So why is it bad that in the example class B is considered a "subclass" of os.PathLike by implementing the protocol? Since it implements the expected protocol what exactly is being lost by not checking for an explicit registration or subclass?

So why is it bad that in the example class B is considered a "subclass" of os.PathLike by implementing the protocol?

This is not bad, my understanding of the problem is that currently B is considered a subclass of A, while the latter should not be structural.

To give an analogy with PEP-544 (sorry, this is my favourite one :-)) consider this:

class P(Protocol):
    def some(self): ...

class C:
    def some(self): ...

Here C is obviously a "subclass" of P, but:

class Bad(P):  # <- this is _no_ a protocol, just a nominal class
    pass       # explicitly subclassing P

class Good(P, Protocol):  # <- this is a subprotocol that
    pass                  # happened to be identical to P

So here C is a "subclass" of Good, but not a "subclass" of Bad.

Just for reference/existing behavior:

>>> class A(collections.abc.Iterable): pass
...
>>> class B:
...   def __iter__(): pass
...
>>> issubclass(B, A)
False
>>> issubclass(B, collections.abc.Iterable)
True
>>> issubclass(A, collections.abc.Iterable)
True

A better example is this:

    class A(PathLike):
        def foo(self):
            """For all your foo needs"""

    class B:
        def __fspath__(self):
            pass

issubclass(B, A) == True
A().foo() # Yay, I Foo'd.
B().foo() # oh barnacles, I should have stayed at home.

Ready for merge

New changeset eae87e3 by Ivan Levkivskyi (Bar Harel) in branch 'master':
bpo-38878: Fix os.PathLike __subclasshook__ (GH-17336)
eae87e3

New changeset 0846e5d by Ivan Levkivskyi (Bar Harel) in branch '3.8':
[3.8] bpo-38878: Fix os.PathLike __subclasshook__ (GH-17336) (GH-17684)
0846e5d

New changeset 59d06b9 by Ivan Levkivskyi (Bar Harel) in branch '3.7':
[3.7] bpo-38878: Fix os.PathLike __subclasshook__ (GH-17336) (GH-17685)
59d06b9