typing._tp_cache runs the wrapped function twice when it raises TypeError

[fedonman]

Bug report

While looking at the typing module I noticed that _tp_cache can run the function it wraps twice.

_tp_cache wraps __getitem__ and similar methods with an lru_cache. Some of the arguments passed to those methods can be unhashable, so it calls the cached version inside a try and falls back to calling the original function when a TypeError shows up, on the assumption that the TypeError came from trying to hash an unhashable argument.

The problem is that the wrapped function can also raise TypeError on its own, for reasons that have nothing to do with hashing. When that happens with hashable arguments, the function runs once inside the cached call and raises, the except TypeError catches it, and then the fallback runs the same function a second time before the error finally propagates.

A small reproduction:

import typing

calls = []

@typing._tp_cache
def f(x):
    calls.append(x)
    raise TypeError("unrelated to hashability")

try:
    f("value")
except TypeError:
    pass

print(calls)  # ['value', 'value'] -- f ran twice

It is also reachable through the public API. Any subscription whose cached __getitem__ validates its arguments and raises TypeError for hashable arguments hits this:

import typing

typing.List[int, str]               # too many arguments
typing.Optional[int, str]           # requires a single type
typing.Callable[[int], (int, str)]  # result must be a type

For typing.List[int, str] the whole __getitem__ body runs twice, including the per-argument _type_check calls, before the TypeError is raised.

The relevant code is in Lib/typing.py:

def inner(*args, **kwds):
    try:
        return _caches[func](*args, **kwds)
    except TypeError:
        pass  # All real errors (not unhashable args) are raised below.
    return func(*args, **kwds)

The fix is to only fall back when the arguments are actually unhashable, and to re-raise otherwise so the function is not called a second time.

Reproduced on current main.

Linked PRs

• gh-154115: Fix typing._tp_cache calling the wrapped function twice on TypeError #154119

[picnixz]

typing._tp_cache is a private function. Does it cause issues in the stdlib itself? private functions have contracts that callers must respect, and if they don't, then ew don't enforce them at runtime.

EDIT: nvm, I missed the part about typing.List, though the latter is deprecated. Does it happen with collections.abc.* as well?

[fedonman]

No, collections.abc doesn't have this behavior. Those types don't use _tp_cache.

[fedonman]

However It's not tied to typing.List either. Any _tp_cache-wrapped subscription that raises TypeError with hashable args runs its body twice, including non-deprecated forms like typing.Optional, typing.Final, typing.Concatenate, and Generic.__class_getitem__ on a user generic. Small repro on Optional:

import typing

# An ordinary, hashable type argument whose comparison typing performs while
# validating it. It records each time typing looks at it.
class Probe:
    seen = 0
    def __eq__(self, other):
        Probe.seen += 1
        raise TypeError("Probe cannot be compared")
    __hash__ = object.__hash__

# Optional[...] runs _type_check on the argument, which does `arg in (Any, ...)`,
# i.e. calls Probe.__eq__. Optional is NOT deprecated.
try:
    typing.Optional[Probe()]
except TypeError:
    pass

print("evaluated the argument", Probe.seen, "time(s)")

On current Python that prints 2, with the fix it prints 1.