gh-150716: Speed up timedelta construction for integer arguments

[gaborbernat]

Callers usually build datetime.timedelta from whole numbers of seconds, minutes, or days, yet that common case runs through the same construction path as float and other arguments.

This adds a direct path for whole-number arguments. Other inputs (float, bool, int subclasses, values too large to fit) keep the current behavior, so results and error messages stay the same.

Code that creates timedeltas in bulk gains the most: a pipeline turning a per-row second count into timedelta(seconds=value) over millions of rows, a scheduler handing out timedelta(minutes=n) to thousands of jobs, or retry logic computing timedelta(seconds=2 ** attempt) in a loop.

A pyperf comparison of base versus patched builds (script and full table in a comment below) shows the integer cases run 2.0 to 3.5x faster, geometric mean 2.15x, with the float path flat. A reference check over hundreds of thousands of argument combinations, including overflowing ones, found no differences. This follows the date.today() fast path from gh-88473.

Resolves #150716.

[StanFromIreland]

Can you please write a benchmark (ideally using pyperf)?

[gaborbernat]

Benchmark below, using pyperf. I built two interpreters from this branch's base (main ancestor) and the patch, ran the same script under each, and compared with pyperf compare_to. macOS arm64, non-PGO; the box is not isolated, so treat sub-nanosecond jitter with care, but the 2-3.5x deltas sit far outside the noise.

Script:

import pyperf

SETUP = "from datetime import timedelta"
CASES = {
    "timedelta()": "timedelta()",
    "timedelta(seconds=45)": "timedelta(seconds=45)",
    "timedelta(days=7)": "timedelta(days=7)",
    "timedelta(microseconds=123456)": "timedelta(microseconds=123456)",
    "timedelta(days=2,h=3,m=4,s=5)": "timedelta(days=2, hours=3, minutes=4, seconds=5)",
    "timedelta(days=-1,seconds=-1)": "timedelta(days=-1, seconds=-1)",
    "timedelta(weeks=3)": "timedelta(weeks=3)",
    "timedelta(seconds=1.5)  # float/slow path": "timedelta(seconds=1.5)",
}
runner = pyperf.Runner()
for name, stmt in CASES.items():
    runner.timeit(name=name, stmt=stmt, setup=SETUP)

Results (pyperf compare_to base.json patched.json --table):

+-----------------------------------------------+---------+-----------------------+
| Benchmark                                     | td_base | td_patched            |
+===============================================+=========+=======================+
| timedelta()                                   | 66.0 ns | 18.8 ns: 3.51x faster |
+-----------------------------------------------+---------+-----------------------+
| timedelta(seconds=45)                         | 127 ns  | 62.8 ns: 2.02x faster |
+-----------------------------------------------+---------+-----------------------+
| timedelta(days=7)                             | 151 ns  | 56.8 ns: 2.66x faster |
+-----------------------------------------------+---------+-----------------------+
| timedelta(microseconds=123456)                | 139 ns  | 68.6 ns: 2.03x faster |
+-----------------------------------------------+---------+-----------------------+
| timedelta(days=2,hours=3,minutes=4,seconds=5) | 297 ns  | 126 ns: 2.36x faster  |
+-----------------------------------------------+---------+-----------------------+
| timedelta(days=-1,seconds=-1)                 | 194 ns  | 77.0 ns: 2.52x faster |
+-----------------------------------------------+---------+-----------------------+
| timedelta(weeks=3)                            | 185 ns  | 90.8 ns: 2.04x faster |
+-----------------------------------------------+---------+-----------------------+
| timedelta(seconds=1.5) [float/slow path]      | 151 ns  | 152 ns: 1.01x slower  |
+-----------------------------------------------+---------+-----------------------+
| Geometric mean                                | (ref)   | 2.15x faster          |
+-----------------------------------------------+---------+-----------------------+

The integer cases run 2.0-3.5x faster, geometric mean 2.15x. The float argument keeps the original path and stays flat (1.01x is within noise).