gh-130167: Improve speed of inspect.formatannotation by replacing re

[donbarbos]

timeit benchmark with my script:

inspect_bench.py:

importreimporttimeitfromtypingimportList, Dict, Any, Uniondefold_format_annotation(annotation):
ifgetattr(annotation, "__module__", None) =="typing":
defrepl(match):
text=match.group()
returntext.removeprefix("typing.")
returnre.sub(r"[\w\.]+", repl, repr(annotation))
returnrepr(annotation)
defnew_format_annotation(annotation):
ifgetattr(annotation, "__module__", None) =="typing":
return (repr(annotation)
.replace(".typing.", "@TYPING@")
.replace("typing.", "")
.replace("@TYPING@", ".typing."))
returnrepr(annotation)
old_time=timeit.timeit(lambda: old_format_annotation(Union[List[str], Dict[str, Any]]), number=100_000)
new_time=timeit.timeit(lambda: new_format_annotation(Union[List[str], Dict[str, Any]]), number=100_000)
print(f"Old version (re.sub): {old_time:.6f}s")
print(f"New version (.replace()): {new_time:.6f}s")
print(f"Difference: {old_time/new_time:.2f}x")

Result: 2.0s -> 1.18s = x1.74 as fast

$ ./python -B inspect_bench.py
Old version (re.sub): 2.043900s
New version (.replace()): 1.175867s
Difference: 1.74x

✔️ This was also the only use of re in module so i got rid of the import

• Issue: Improve speed of stdlib functions by replacing re uses #130167

[AA-Turner]

I'm less sure this is worth it, the replacement isn't clearly better maintenence-wise.

What do the benchmarks look like if you extract repl to a module-level _formatannotation_repl and use .sub() on a pre-compiled pattern?

A

[donbarbos]

sorry, I forgot how python was compiled then :( but I'm pretty sure I compiled it with gcc last time

so I reran the test with the following config args '--enable-optimizations' '--with-lto' 'CC=/usr/bin/clang-18' and got a new result for my bench:

Old version (re.sub): 0.982520s
New version (.replace()): 0.701049s
Difference: 1.40x # sometimes it's 1.35x

and if we rewrite old version of benchmark as you suggested:

_pattern=re.compile(r"[\w\.]+")
def_repl(match):
text=match.group()
returntext.removeprefix("typing.")
defold_format_annotation(annotation):
ifgetattr(annotation, "__module__", None) =="typing":
returnre.sub(_pattern, _repl, repr(annotation))
returnrepr(annotation)

we will get a bigger difference:

Old version (re.sub): 1.027774s
New version (.replace()): 0.698902s
Difference: 1.47x # the result can drop to 1.40

P.S.: another reason i like the PR version is because we get rid of the re import that is used once here

[Engelbarts]

Out of curiosity, why use the little replace dance in the refactored code instead of just return repr(annotation).removeprefix("typing.")?

[charmander]

Out of curiosity, why use the little replace dance in the refactored code instead of just return repr(annotation).removeprefix("typing.")?

- Union[typing.List[str], typing.Dict[str, typing.Any]]+ Union[List[str], Dict[str, Any]]

The replace dance is pretty messy, though, and doesn’t preserve behaviour for footyping.Bar – not that applying a regex to repr output is perfectly reliable to begin with (def foo() -> Literal["typing."]: ...).

For what it’s worth:

pat=re.compile(r"\b(?<!\.)typing\.")
pat.sub("", repr(annotation))

[github-actions]

This PR is stale because it has been open for 30 days with no activity.