Backport performance improvements to runtime-checkable protocols

[AlexWaygood]

This PR backports the following CPython PRs (all by me), which, taken together, substantially improve the performance of isinstance() checks against runtime-checkable protocols on Python 3.12 compared to Python 3.11:

• gh-74690: typing: Don't unnecessarily call _get_protocol_attrs twice in _ProtocolMeta.__instancecheck__ cpython#103141
• gh-74690: Micro-optimise typing._get_protocol_attrs cpython#103152
• gh-74690: typing: Simplify and optimise _ProtocolMeta.__instancecheck__ cpython#103159
• gh-74690: typing: Call _get_protocol_attrs and _callable_members_only at protocol class creation time, not during isinstance() checks cpython#103160
• gh-74690: Further optimise typing._ProtocolMeta.__instancecheck__ cpython#103280

Here is a benchmark script:

import time
from typing_extensions import Protocol, runtime_checkable

@runtime_checkable
class HasX(Protocol):
    x: int

@runtime_checkable
class SupportsInt(Protocol):
    def __int__(self) -> int: ...

@runtime_checkable
class SupportsIntAndX(Protocol):
    x: int
    def __int__(self) -> int: ...

class Empty:
    description = "Empty class with no attributes"

class Registered:
    description = "Subclass registered using ABCMeta.register"

HasX.register(Registered)
SupportsInt.register(Registered)
SupportsIntAndX.register(Registered)

class PropertyX:
    description = "Class with a property x"
    @property
    def x(self) -> int:
        return 42

class HasIntMethod:
    description = "Class with an __int__ method"
    def __int__(self):
        return 42

class PropertyXWithInt:
    description = "Class with a property x and an __int__ method"
    @property
    def x(self) -> int:
        return 42
    def __int__(self):
        return 42

class ClassVarX:
    description = "Class with a ClassVar x"
    x = 42

class ClassVarXWithInt:
    description = "Class with a ClassVar x and an __int__ method"
    x = 42
    def __int__(self):
        return 42

class InstanceVarX:
    description = "Class with an instance var x"
    def __init__(self):
        self.x = 42

class InstanceVarXWithInt:
    description = "Class with an instance var x and an __int__ method"
    def __init__(self):
        self.x = 42
    def __int__(self):
        return 42
    
class NominalX(HasX):
    description = "Class that explicitly subclasses HasX"
    def __init__(self):
        self.x = 42

class NominalSupportsInt(SupportsInt):
    description = "Class that explicitly subclasses SupportsInt"
    def __int__(self):
        return 42

class NominalXWithInt(SupportsIntAndX):
    description = "Class that explicitly subclasses NominalXWithInt"
    def __init__(self):
        self.x = 42


num_instances = 500_000

classes = {}
for cls in (
    Empty, Registered, PropertyX, PropertyXWithInt, ClassVarX, ClassVarXWithInt,
    InstanceVarX, InstanceVarXWithInt, NominalX, NominalXWithInt, HasIntMethod,
    NominalSupportsInt
):
    classes[cls] = [cls() for _ in range(num_instances)]


def bench(objs, title, protocol):
    start_time = time.perf_counter()
    for obj in objs:
        isinstance(obj, protocol)
    elapsed = time.perf_counter() - start_time
    print(f"{title}: {elapsed:.2f}")


print("Protocols with no callable members\n")
for cls in Empty, Registered, PropertyX, ClassVarX, InstanceVarX, NominalX:
    bench(classes[cls], cls.description, HasX)

print("\nProtocols with only callable members\n")
for cls in Empty, Registered, HasIntMethod, NominalSupportsInt:
    bench(classes[cls], cls.description, SupportsInt)

print("\nProtocols with callable and non-callable members\n")
for cls in (
    Empty, Registered, PropertyXWithInt, ClassVarXWithInt, InstanceVarXWithInt,
    NominalXWithInt
):
    bench(classes[cls], cls.description, SupportsIntAndX)

Benchmark results on `main`, using Python 3.11

Protocols with no callable members

Empty class with no attributes: 4.29
Subclass registered using ABCMeta.register: 20.07
Class with a property x: 14.12
Class with a ClassVar x: 14.08
Class with an instance var x: 14.02
Class that explicitly subclasses HasX: 14.04

Protocols with only callable members

Empty class with no attributes: 14.14
Subclass registered using ABCMeta.register: 21.59
Class with an __int__ method: 7.06
Class that explicitly subclasses SupportsInt: 7.04

Protocols with callable and non-callable members

Empty class with no attributes: 15.43
Subclass registered using ABCMeta.register: 24.64
Class with a property x and an __int__ method: 15.52
Class with a ClassVar x and an __int__ method: 15.28
Class with an instance var x and an __int__ method: 15.27
Class that explicitly subclasses NominalXWithInt: 15.28

Benchmark results with this PR branch, using Python 3.11

Protocols with no callable members

Empty class with no attributes: 0.58
Subclass registered using ABCMeta.register: 0.56
Class with a property x: 0.27
Class with a ClassVar x: 0.26
Class with an instance var x: 0.26
Class that explicitly subclasses HasX: 0.21

Protocols with only callable members

Empty class with no attributes: 0.59
Subclass registered using ABCMeta.register: 1.27
Class with an __int__ method: 0.19
Class that explicitly subclasses SupportsInt: 0.19

Protocols with callable and non-callable members

Empty class with no attributes: 0.60
Subclass registered using ABCMeta.register: 1.57
Class with a property x and an __int__ method: 1.03
Class with a ClassVar x and an __int__ method: 0.97
Class with an instance var x and an __int__ method: 0.97
Class that explicitly subclasses NominalXWithInt: 0.67

Note that if we choose to backport python/cpython#103034 (using inspect.getattr_static instead of getattr in _ProtocolMeta.__instancecheck__), it will undo a lot of the performance improvements that this PR brings. I leave the decision of whether or not to backport that PR to another PR/issue.

[AlexWaygood]

This change was required because typing._collect_type_vars doesn't exist on Python 3.11 (but typing_extensions._collect_type_vars does), and with this PR, we now re-implement Protocol on <=3.11, whereas we previously only re-implemented it on <=3.9

[AlexWaygood]

This change was required in order for tests to pass on Python 3.11. Without this change, a function somewhere was failing with NameError when the tests were run on Python 3.11, because the function was calling _is_unpack(), and we previously only defined _is_unpack on Python <=3.10.

[AlexWaygood]

We could possibly also backport "fast versions" of the runtime-checkable protocols that the typing module provides: https://docs.python.org/3/library/typing.html#protocols

As a result of the performance improvements I'm backporting here, isinstance() checks against the typing versions of these protocols should be much faster on 3.12 than it is on 3.11.

[Tenzer]

This change seems to have broken the latest version of pydash when used with typing-extensions 4.6.0. There's a bug report about this here: dgilland/pydash#197.

I did a bisect of every change between typing-extensions 4.5.0 and 4.6.0, and this was pointed out as the culprit. I've had a look at the code changes here but don't have a good enough grasp of what's going wrong that is causing this to fail.

This seems to be the relevant Pydash code that relates to the error:
https://github.com/dgilland/pydash/blob/051fe69c3e523f903a0a0ea6ca6a5c2d4b83a3e7/src/pydash/utilities.py#L577-L638

[AlexWaygood]

Thanks @Tenzer, looks to me like it's probably a bug in typing_extensions. I've opened #181 so we can track this properly.

[Tenzer]

Cheers!