Repository navigation
Make singledispatch only evaluate annotation for dispatched arg #110373
Description
Activity
@AlexWaygood suggested in #119891 (comment) that the PEP 649 changes could fix this issue too. Unfortunately, PEP 649 does not allow the example above to pass, because when you call an
__annotate__function, all the code is always evaluated, so1/0gets run and throws an error. The tricks that we add to support forward references work if you use undefined names, but not for other runtime errors.The good news is that something like this (more realistic than
1/0in an annotation) does now work on main:from typing import TYPE_CHECKING if TYPE_CHECKING: from expensive import SomeType from functools import singledispatch @singledispatch def fun(arg, verbose): return "fun" @fun.register def _(arg: int, verbose: SomeType): return "int fun" fun("x", None) # fun fun(1, None) # int fun
But the OP's example above will still fail. We could fix this by a solution like making
__annotate__support an optional parameter saying it should only evaluate some of the annotations. I personally feel that's not worth the effort, but I'm open to other opinions.Reacted by Bartosz SławeckiThis is a nuanced one. I personally don't think it's worth it as well -- it's a special case.
A potential time of revisit is when the lazy imports feature gets merged.
We use singledispatch a lot with dummy classes:
if TYPE_CHECKING or find_spec("optional-dep"): from optional_dep import Thing else: Thing = type("Thing", (), dict(__module__="optional_dep")) @singledispatch def f(obj): ... @f.register(Thing) def _(obj): ...
For this to be replaced with lazy imports, we really do need something new.
In the example below, we have no real need to evaluate the type annotations of the non-dispatched args.
Skipping this might improve performance / import time a little.
While a little late for some nice features like
X | Ysyntax, this is useful in case we introduce new typing syntax in the future, since it allows users to use it on non-dispatched args.