Currently the first lines in PyObject_IsSubClass are:

    /* We know what type's __subclasscheck__ does. */
    if (PyType_CheckExact(cls)) {
        /* Quick test for an exact match */
        if (derived == cls)
            return 1;
        return recursive_issubclass(derived, cls);
    }

The if (derived == cls) runs only if PyType_CheckExact is True which doesn't hold for any classes with a custom metaclass. As a result, a check of the form issubclass(Sequence, Sequence) will take a slow path that invokes __subclasscheck__.

I'm not sure if this was placed inside there due to some wild edge-case, though. PyObject_IsInstance uses the same trick and does so outside the if (PyType_CheckExact(cls)) check.

I'll gladly submit a PR if this indeed needs fixing and not by design.

Additional question, are tests required to check this behavior? (Also, bumping)

Will deeply grokking this code, I would say to leave it alone.  The test seems reasonable and is very fast (likely free of cost on many machines).

Jim doesn't propose to remove fast test, it proposes to add a test for fast path for avoiding invoking __subclasscheck__ (this is slow). This can change semantic, but isinstance() already contains such fast path.

This is similar to testing "elem is seq[i]" before "elem == seq[i]" when search in sequences. This optimization changes semantic for NaNs. Does a "Not-A-Class" class which is not a subclass of itself (issubclass(C, C) returns False) makes any sense?

My point was that it isn't wise to propose PRs for code you don't fully understand (he said, "I'm not sure if this was placed inside there due to some wild edge-case,").

> he said, "I'm not sure if this was placed inside there due to some wild edge-case,"

As a new contributor, I'll always lean on the side of me not seeing something rather than confidently stating that something is definitely wrong. I'm new, the code-base is 20 years old and worked on by a dozen of experienced devs :-)

>  Does a "Not-A-Class" class which is not a subclass of itself (issubclass(C, C) returns False) makes any sense?

I'm not sure. Apart from the performance impact, there's a behavioral discrepancy between isinstance and issubclass as you also stated. 

In isinstance, __instancecheck__ doesn't *always* get a chance to override the behavior. The `if type(inst) == Cls` [1] stops it before it gets a chance. 
In issubclass, __subclasscheck__ does override it:

    class Meta(type):
        def __instancecheck__(self, other):
            print("invoked")
            return False
        def __subclasscheck__(self, other):
            print("invoked")
            return False

    class Cls(metaclass=Meta):
        pass

    isinstance(Cls(), Cls)
    True

    issubclass(Cls, Cls)
    invoked
    False

So, I guess the question might be re-framed to: Is it guaranteed that __instancecheck__ and __subclasscheck__ are *always* called?

If yes: PyObject_IsInstance should be tweaked.
If no:  PyObject_IsSubclass should be tweaked.

p.s Should I maybe move this to python-dev?

[1]: https://github.com/python/cpython/blob/master/Objects/abstract.c#L2338

Yes, please move this to Python-Dev.

Any progress?