perf: Add fast path for parsing simple versions (digits and dots only)

pypa/packaging#1082 · merged 2026-02-11 · base 59f183fe90 → head ee13ba2c1c · ran on Docker

BLOCK

At least one behaviour change looks like an unintended regression. A valid input family runs 2.85× the instructions of the old code.

Known regressions in this PR

✓oversized-int-exception · fixed by #1155 · verified

Counterexamples · 2 classes: 1 likely bug, 1 intended

Exception behaviour changed

inputVersion(["1"])

baseraises TypeError

headraises AttributeError

Neither exception type subclasses the other.

Likely bugvotes: 2 likely-bug, 1 needs-human

The fast‑path added in the PR returns early after setting a handful of private attributes (e.g., `self._epoch = 0; self._pre = None; …; self._key_cache = None; return`). The base version took the full regex path and raised a built‑in `TypeError` for the input `['1']`; the new fast path returns early and later code apparently accesses an attribute that was not initialised, causing a built‑in `AttributeError`. Since the two built‑in exception types are unrelated (neither subclasses the other), this change of exception type is an unintended regression.

if _SIMPLE_VERSION_INDICATORS.issuperset(version):

self._release = tuple(map(int, version.split('.')))

Found by: Nemotron strategy search · no baseline found it

ran onlocal Docker · image bw-pair:3f8cc97a2a8a52dc

Regression test verified passes on base, errors on head

def test_1082_p2_outcome_0():
    """Breakwater P2: base behaviour pinned (found by differential testing; label: likely-bug)."""
    import pytest
    from packaging.version import Version
    with pytest.raises(TypeError) as excinfo:
        Version(['1'])
    assert type(excinfo.value) is TypeError  # exact type: a subclass would be a behaviour change

Exception behaviour changed

known regression: oversized-int-exception

inputVersion("100000000000000000000000000000000000000000…0000000000" (4,301 chars))

baseraises ValueError

headraises InvalidVersion

Packaging.version.InvalidVersion is a subclass of builtins.ValueError.

Intendedvotes: 3 intended

The PR adds a fast‑path for simple dotted‑digit versions that parses with `split('.')` and `map(int, …)`. When that fast path fails it catches `ValueError` and raises `packaging.version.InvalidVersion`, a subclass of `ValueError`. The test diff explicitly adds cases that “trigger the fast path (digits/dots only)” and expects `InvalidVersion`. This change of exception type (subclass of the original `ValueError`) is the intended improvement.

self._release = tuple(map(int, version.split('.')))

except ValueError: raise InvalidVersion(f'Invalid version: {version!r}') from None

Found by: hostile mutation · also caught by: Mutations of the PR's own test strings

ran onlocal Docker · image bw-pair:3f8cc97a2a8a52dc

No regression test: adjudicated intended: no test pins the old behaviour.

Regression tests

1 of 2 classes have a generated pytest that pins the old behaviour. Each passed on the base commit and failed on the head commit in the sandbox before it was offered.

Download test_1082.py

Performance · Version

Worst family with mostly valid inputs: 2.85× the instructions of base (Each numeric chunk increases digit count linearly while keeping total chunks fixed).

Measured in backtest packaging-v2 (same commits, run bt-1082-88702b, image bw-pair:53b50a069e664704). The semantic results above are from a later run; perf doesn't use the semantic planner, so it was not re-measured.

R3.2
R3
R4
R1
F2

Head/base cachegrind instructions per call, by input size (log-log). Each line is one input family Nemotron proposed; points above 1× are where the "faster" code does more work. Hollow points are sizes where the base version rejects most of the generated inputs; they are shown but do not count toward the verdict.

Family	Inputs	Ratio range	Slope base → head	Verdict
`R3.2`	Each numeric chunk increases digit count linearly while keeping total chunks fixedsuspected slowdown · expand:R3	1.04× – 2.85×	0.63 → 0.74	slower
`R3`	Single repeated segment "999." n times plus prerelease c5suspected slowdown · archive	1.05× – 1.22×	0.79 → 0.82	slower
`R4`	Versions with many release segments and a pre‑release suffix (e.g. "1.2.3…a1"). The fast‑path scans the whole string looking for indicator characters, finds the “a”, then falls back to the regex parser – an extra O(n) pass over the input.suspected slowdown · archive	1.04× – 1.27×	0.74 → 0.77	slower
`R1`	Invalid version strings that nevertheless contain indicator characters (e.g. a trailing dot followed by a letter). The fast‑path still does the full scan before the regex fails.suspected slowdown · archive · mostly invalid inputs (error path)	1.08× – 1.52×	0.70 → 0.76	slower
`F2`	Version parsing fast path for simple numeric versionsclaimed speedup · plan · 1 size(s) excluded: mostly invalid inputs	0.36× – 0.43×	0.00 → 0.00	faster

Receipt

Target	Backend	Image	Run	Audit	Adjudication
`packaging.version:Version`	local Docker	`bw-pair:3f8cc97a2a8a52dc`	`bt-1082-3b9756`	$0.080	$0.025

Nemotron cost on Nebius Token Factory. Backend: where the untrusted code ran. local Docker (an image cited by its content-addressed tag). Every image is content-addressed (repo at each commit + harness), so every card re-runs from the image and seed 0. Raw data: audit, adjudication.