{ "run_id": "e780ff68654f", "repo": "https://github.com/pypa/packaging", "base": "59f183fe90da", "head": "61967cca278d", "target": "packaging.version:Version", "title": "perf: fast path for simple versions (intermediate commit 61967cca)", "provider": "tokenfactory", "semantic": { "run_id": "e780ff68654f", "repo": "https://github.com/pypa/packaging", "base": "59f183fe90da", "head": "61967cca278d", "target": "packaging.version:Version", "image": "dbe8dafe-78c4-4fc8-b8c2-a5adaad2ed49", "backend": "contree", "attacks": [ { "id": "A1", "routing_condition": "The input string has no characters from _NON_SIMPLE_VERSION_INDICATORS, therefore the fast‑path branch is taken.", "assumption": "The fast‑path guard assumes that a version lacking the indicator characters contains only ASCII digits and dots, so it splits on '.' and feeds each piece to int().", "why_it_breaks": "base: The old __init__ falls through to the full regex (self._regex.fullmatch). The pattern does not allow whitespace between the dot and the digits, so the match fails and InvalidVersion is raised.; head: The fast‑path executes: version.strip().split('.') yields pieces like '1 ' and '2'; int() accepts the surrounding whitespace, so a Version object is created with release=(1, 2).", "input_family": "versions with spaces adjacent to the dot separator", "example_args": [ [ "1 .2" ], [ "1. 2" ] ], "difference": "accepts what base rejects" }, { "id": "A2", "routing_condition": "The guard `_NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version)` is true for a string that contains only Unicode digits (e.g. full‑width “１” “２”) and dots, because those characters are not in the indicator set.", "assumption": "The fast‑path guard assumes that any string lacking the indicator characters consists only of ASCII digits and dots, so int() will only ever see ASCII digits.", "why_it_breaks": "base: `Version(\"１.２\")` falls through to the regex path; `VERSION_PATTERN` uses `[0-9]` which matches only ASCII digits, so the fullmatch fails and `InvalidVersion` is raised.; head: The fast‑path is taken, `version.strip().split(\".\")` yields `[\"１\", \"２\"]`; `int()` accepts Unicode decimal digits, producing `(1, 2)`. A `Version` instance is created with `release=(1, 2)` and no exception.", "input_family": "PEP‑440‑like release segment written with non‑ASCII decimal digits", "example_args": [ [ "１.２" ] ], "difference": "accepts what base rejects" }, { "id": "A3", "routing_condition": "`_NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version)` is true for strings that contain only Unicode decimal digits and dots.", "assumption": "The fast‑path assumes `int()` only accepts ASCII decimal digits; it treats any string without the indicator characters as a simple numeric version.", "why_it_breaks": "base: The regex `VERSION_PATTERN` only matches ASCII `[0-9]` in the release segment, so `Version(\"١.٢.٣\")` raises `InvalidVersion`.; head: The fast‑path runs `version.strip().split('.')` and `map(int, …)`. `int()` accepts Unicode decimal digits, so the version is accepted and normalized to `(1, 2, 3)`.", "input_family": "non‑ASCII decimal digits (Arabic‑Indic)", "example_args": [ [ "١.٢.٣" ] ], "difference": "accepts what base rejects" }, { "id": "A4", "routing_condition": "The input contains only Unicode digits and the dot character, none of which are in _NON_SIMPLE_VERSION_INDICATORS, so the fast‑path branch runs.", "assumption": "The fast‑path guard assumes that a version without indicator characters consists solely of ASCII decimal digits, but int() also accepts any Unicode decimal digit.", "why_it_breaks": "base: The regex uses [0-9] for the release segment, which matches only ASCII digits; the fullmatch fails and InvalidVersion is raised.; head: The fast‑path splits on '.' and calls int() on each segment; int() accepts full‑width digits (e.g. U+FF11), so a Version object is created with release=(1, 2).", "input_family": "versions written with non‑ASCII decimal digits", "example_args": [ [ "１.２" ], [ "１２３.４５６" ] ], "difference": "accepts what base rejects" }, { "id": "A5", "routing_condition": "`_NON_SIMPLE_VERSION_INDICATORS.isdisjoint(\"1 .2\")` is true because space is not in the indicator set.", "assumption": "The fast‑path guard assumes that a string without indicator characters contains no whitespace inside the release segment.", "why_it_breaks": "base: Regex `\\s*` only permits leading/trailing whitespace; the pattern for `release` (`[0-9]+(?:\\.[0-9]+)*`) does not allow a space between a digit and a dot, so `fullmatch` fails and `InvalidVersion` is raised.; head: Fast‑path executes; `strip()` removes only leading/trailing whitespace, `split(\".\")` gives `[\"1 \", \"2\"]`; `int(\"1 \")` succeeds (int ignores surrounding whitespace), producing `release=(1, 2)`. A `Version` instance is returned.", "input_family": "Release segment with ASCII whitespace around the dot separator", "example_args": [ [ "1 .2" ], [ "1. 2" ] ], "difference": "accepts what base rejects" } ], "strategies": [ { "id": "A1/s1", "attack": "A1", "valid": false, "error": "code must assign `strategy`", "examples": 0, "findings": 0, "source": "st.tuples(st.just(\" \"), st.integers(0, 99), st.just(\".\"), st.integers(0, 99))" }, { "id": "A1/s2", "attack": "A1", "valid": true, "error": null, "examples": 300, "findings": 0, "source": "strategy = st.lists(\n st.just(\" \") | st.just(\"\") | st.integers() | st.floats(allow_nan=False, allow_infinity=False),\n min_size=1,\n max_size=4,\n).map(lambda pieces: \".\".join(str(p) for p in pieces))" }, { "id": "A1/s3", "attack": "A1", "valid": true, "error": null, "examples": 441, "findings": 1, "source": "strategy = st.tuples(\n st.text(\n alphabet=string.digits + \" .\",\n min_size=1,\n max_size=5,\n ),\n st.just(\"\"),\n st.just(\" \"),\n st.one_of(st.text(alphabet=string.digits, min_size=1, max_size=3), st.none()),\n).map(lambda parts: \"\".join(parts[0:3]) + parts[3] if parts[3] else \"\".join(parts[0:3]),\n # interleave spaces around dots: keep digits and single spaces, then rebuild\n # to produce inputs like \"1 .2\", \"1. 2\", \"1 . 2\", etc.\n)" }, { "id": "A1/s4", "attack": "A1", "valid": true, "error": null, "examples": 384, "findings": 1, "source": "strategy = st.tuples(\n st.text(\n alphabet=string.digits + \" .\",\n min_size=1,\n max_size=20,\n ).map(lambda txt: txt.strip()),\n st.just(\".\"),\n st.text(\n alphabet=string.digits + \" \",\n min_size=1,\n max_size=10,\n ).map(lambda txt: txt.strip()),\n).map(lambda args: (args[0] + args[2],)).map(tuple)" }, { "id": "A2/s1", "attack": "A2", "valid": true, "error": "AttributeError: 'function' object has no attribute 'CharSet'", "examples": 0, "findings": 0, "source": "strategy = st.lists(\n st.text(alphabet=st.characters(sets=[st.characters.CharSet(0xff10, 0xff19)]), min_size=1, max_size=4),\n min_size=1, max_size=4\n).map(lambda parts: \".\".join(parts))" }, { "id": "A2/s2", "attack": "A2", "valid": true, "error": null, "examples": 304, "findings": 1, "source": "strategy = st.lists(\n st.one_of(\n st.just(\"１\"),\n st.just(\"２\"),\n st.just(\"３\"),\n st.just(\"．\"),\n st.just(\"１．\"),\n st.just(\"２．\"),\n st.just(\"１．２\"),\n st.just(\"１．２．３\"),\n ),\n min_size=1,\n max_size=4,\n)" }, { "id": "A2/s3", "attack": "A2", "valid": true, "error": null, "examples": 300, "findings": 0, "source": "strategy = st.tuples(\n st.text(\n alphabet=string.digits + \"０１２３４５６７８９\",\n min_size=1,\n max_size=50,\n ).filter(lambda s: all(c in string.digits + \"０１２３４５６７８９\" + \".\" for c in s)),\n st.integers(min_value=0, max_value=999),\n)" }, { "id": "A2/s4", "attack": "A2", "valid": false, "error": "code must assign `strategy`", "examples": 0, "findings": 0, "source": "st.lists(st.just(st.sampled_from([\"１\", \"２\", \"３\", \"４\", \"５\", \"６\", \"７\", \"８\", \"９\", \"０\"])), min_size=1, max_size=5) | st.tuples(st.just(st.sampled_from([\"１\", \"２\", \"３\", \"４\", \"５\", \"６\", \"７\", \"８\", \"９\", \"０\"])), min_size=1, max_size=5) | st.just(\"１.２\") | st.just(\"０.０\")" }, { "id": "A3/s1", "attack": "A3", "valid": true, "error": null, "examples": 319, "findings": 1, "source": "strategy = st.lists(\n st.text(\n alphabet=string.digits + \"\\u0660\\u0661\\u0662\\u0663\\u0664\\u0665\\u0666\\u0667\\u0668\\u0669\",\n min_size=1,\n max_size=5,\n ),\n min_size=1,\n max_size=3,\n).map(lambda parts: \".\".join(parts))" }, { "id": "A3/s2", "attack": "A3", "valid": true, "error": "TypeError: sequence item 0: expected str instance, int found", "examples": 0, "findings": 0, "source": "strategy = st.lists(\n st.one_of(\n st.integers(min_value=0, max_value=999),\n st.text(\n alphabet=\"٠١٢٣٤٥٦٧٨٩\",\n min_size=1,\n max_size=20,\n ),\n ),\n min_size=1,\n max_size=3,\n).map(lambda parts: \".\".join(parts))" }, { "id": "A3/s3", "attack": "A3", "valid": false, "error": "code must assign `strategy`", "examples": 0, "findings": 0, "source": "st.lists(\n st.text(\n alphabet=st.characters(\n blacklist_categories=('Mn', 'Mc'),\n whitelist_categories=('Nd',),\n min_codepoint=0x0660,\n max_codepoint=0x0669\n ),\n min_size=1,\n max_size=5\n ),\n min_size=1,\n max_size=3,\n unique=True\n).map('.'.join)" }, { "id": "A3/s4", "attack": "A3", "valid": true, "error": null, "examples": 314, "findings": 1, "source": "strategy = st.lists(\n st.text(\n alphabet=string.digits + string.ascii_letters + \"\\u0660\\u0661\\u0662\\u0663\\u0664\\u0665\\u0666\\u0667\\u0668\\u0669\",\n min_size=1,\n max_size=5,\n ),\n min_size=1,\n max_size=3,\n).map(lambda parts: \".\".join(parts))" }, { "id": "A4/s1", "attack": "A4", "valid": false, "error": "code must assign `strategy`", "examples": 0, "findings": 0, "source": "st.tuples(\n st.just(\"version\"),\n st.text(\n alphabet=string.digits.replace(\"0123456789\", \"\".join(chr(0xFF10 + i) for i in range(10))),\n min_size=1,\n max_size=3,\n ).example(\"1\"),\n st.integers(min_value=0, max_value=999),\n).example(\"1.2\")" }, { "id": "A4/s2", "attack": "A4", "valid": true, "error": "TypeError: sequence item 0: expected str instance, int found", "examples": 0, "findings": 0, "source": "strategy = st.lists(\n st.one_of(\n st.integers(min_value=0, max_value=999999),\n st.just(None),\n st.text(alphabet=string.digits.replace(\"0123456789\", \"\").replace(\"０１２３４５６７８９\", \"\"), min_size=1, max_size=6),\n ),\n min_size=1,\n max_size=4,\n).map(lambda parts: \".\".join(parts))" }, { "id": "A4/s3", "attack": "A4", "valid": true, "error": "TypeError: text() got an unexpected keyword argument 'alphabets'", "examples": 0, "findings": 0, "source": "strategy = st.lists(\n st.integers(min_value=0, max_value=999999),\n min_size=1,\n max_size=4\n).map(lambda segs: \".\".join(st.text(alphabets=\"０１２３４５６７８９\", min_size=1, max_size=6).example() for _ in segs))" }, { "id": "A4/s4", "attack": "A4", "valid": false, "error": "code must assign `strategy`", "examples": 0, "findings": 0, "source": "st.tuples(st.text(alphabet=st.characters(min_codepoint=0xFF10, max_codepoint=0xFF19), min_size=1, max_size=5), st.text(alphabet=st.characters(min_codepoint=0x0030, max_codepoint=0x0039), min_size=0, max_size=5), st.text(alphabet=st.characters(min_codepoint=0x002E, max_codepoint=0x002E), min_size=1, max_size=3), st.text(alphabet=st.characters(min_codepoint=0x0030, max_codepoint=0x0039), min_size=0, max_size=5), st.text(alphabet=st.characters(min_codepoint=0x0030, max_codepoint=0x0039), min_size=0, max_size=5), st.text(alphabet=st.characters(min_codepoint=0x0030, max_codepoint=0x0039), min_size=0, max_size=5), st.text(alphabet=st.characters(min_codepoint=0x0030, max_codepoint=0x0039), min_size=0, max_size=5), st.text(alphabet=st.characters(min_codepoint=0x0030, max_codepoint=0x0039), min_size=0, max_size=5), st.text(alphabet=st.characters(min_codepoint=0x0030, max_codepoint=0x0039), min_size=0, max_size=5), max_size=4, min_size=1)" }, { "id": "A5/s1", "attack": "A5", "valid": true, "error": null, "examples": 300, "findings": 0, "source": "strategy = st.tuples(\n st.sampled_from([\".\", \"\"]).flatmap(\n lambda s: st.text(\n alphabet=string.digits + \" .\",\n min_size=1,\n max_size=3\n ).filter(lambda t: s in t)\n ).map(lambda s: f\"1{s}2\"),\n st.text(alphabet=string.digits, min_size=1, max_size=2)\n)" }, { "id": "A5/s2", "attack": "A5", "valid": true, "error": null, "examples": 14, "findings": 1, "source": "# Generates strings where release segment has whitespace adjacent to the dot.\n# Covers cases like \"1 .2\" (space before dot) and \"1. 2\" (space after dot).\n# Lengths vary to trigger edge effects.\nst.text(\n st.characters(whitelist_categories=(\"Nd\", \"Ll\", \"Lu\")),\n min_size=1,\n max_size=10,\n).map(lambda s: \"1\" + (\" \" if st.just(\" \") else \"\") + \".\" + s).example() # placeholder; actual generation below\nstrategy = st.text(\n alphabet=st.characters(whitelist_categories=(\"Nd\", \"Ll\", \"Lu\")),\n min_size=1,\n max_size=15,\n).filter(\n lambda s: \".\" in s\n).map(\n lambda s: s.replace(\" \", \" .\").replace(\".\", \". \").replace(\"..\", \".\") # naive insertion; replaced by explicit tuples below\n) or st.tuples(\n st.integers(min_value=0, max_value=999),\n st.integers(min_value=0, max_value=999),\n).map(lambda t: f\"{t[0]} .{t[1]}\").example()\n# The above is illustrative; the concrete strategy is:\nstrategy = st.one_of(\n st.just(\"1 .2\"),\n st.just(\"1. 2\"),\n st.just(\"1 .2\"),\n st.just(\"1. 2\"),\n st.just(\"1 . 2\"),\n st.just(\"1 .2 \"),\n st.just(\" 1.2\"),\n st.just(\"1.2 \"),\n st.just(\"1 .2.3\"),\n st.just(\"1. 2.3\"),\n)" }, { "id": "A5/s3", "attack": "A5", "valid": true, "error": null, "examples": 300, "findings": 0, "source": "strategy = st.lists(\n st.just(\" \") | st.just(\"\\t\") | st.text(alphabet=string.digits, min_size=1, max_size=2),\n min_size=1,\n max_size=3,\n).map(lambda parts: \".\".join(parts))" }, { "id": "A5/s4", "attack": "A5", "valid": false, "error": "code must assign `strategy`", "examples": 0, "findings": 0, "source": "# Releases with internal whitespace around the dot separator\nst.text(st.just(\"1 \"), st.just(\" 1\"), st.just(\".2\"), st.just(\"2 \")) |\\\n st.tuples(st.text(st.just(\"1\"), st.just(\" \"), st.just(\".2\"), st.just(\" \")),\n st.text(st.just(\"1\"), st.just(\".\"), st.just(\" 2\")))" } ], "findings": [ { "signature": "P2|outcome|exc:packaging.version.InvalidVersion|ok|whitespace", "probe": "P2", "detail": "outcome", "args": [ [ "0 .0" ] ], "base": { "status": "exc", "exc": "packaging.version.InvalidVersion" }, "head": { "status": "ok", "obs": { "str": "0.0", "repr": "", "attr:release": [ 0, 0 ], "attr:public": "0.0" } }, "found_by": [ "A1/s4", "A1/s3", "A5/s2", "seed", "mutation:whitespace-outer", "mutation:whitespace-inner", "mutation:equivalents", "mutation:separators", "batch" ] }, { "signature": "P2|outcome|exc:builtins.TypeError|exc:builtins.AttributeError|nested", "probe": "P2", "detail": "outcome", "args": [ [ [ "１" ] ] ], "base": { "status": "exc", "exc": "builtins.TypeError" }, "head": { "status": "exc", "exc": "builtins.AttributeError" }, "found_by": [ "A2/s2", "batch" ] }, { "signature": "P2|outcome|exc:packaging.version.InvalidVersion|ok|non-ascii", "probe": "P2", "detail": "outcome", "args": [ [ "٠" ] ], "base": { "status": "exc", "exc": "packaging.version.InvalidVersion" }, "head": { "status": "ok", "obs": { "str": "0", "repr": "", "attr:release": [ 0 ], "attr:public": "0" } }, "found_by": [ "A3/s1", "A3/s4", "seed", "mutation:edges", "mutation:separators", "mutation:unicode-digits" ] }, { "signature": "P2|outcome|exc:packaging.version.InvalidVersion|ok|non-ascii+whitespace", "probe": "P2", "detail": "outcome", "args": [ [ "١ .2" ] ], "base": { "status": "exc", "exc": "packaging.version.InvalidVersion" }, "head": { "status": "ok", "obs": { "str": "1.2", "repr": "", "attr:release": [ 1, 2 ], "attr:public": "1.2" } }, "found_by": [ "mutation:unicode-digits", "mutation:whitespace-outer", "mutation:whitespace-inner" ] }, { "signature": "P2|outcome|exc:packaging.version.InvalidVersion|ok|long-digits+whitespace", "probe": "P2", "detail": "outcome", "args": [ [ "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 .2" ] ], "base": { "status": "exc", "exc": "packaging.version.InvalidVersion" }, "head": { "status": "ok", "obs": { "str": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.2", "repr": "", "attr:release": [ "", 2 ], "attr:public": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.2" } }, "found_by": [ "mutation:huge-number" ] }, { "signature": "P2|outcome|exc:builtins.ValueError|exc:packaging.version.InvalidVersion|long-digits", "probe": "P2", "detail": "outcome", "args": [ [ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" ] ], "base": { "status": "exc", "exc": "builtins.ValueError" }, "head": { "status": "exc", "exc": "packaging.version.InvalidVersion" }, "found_by": [ "mutation:huge-number" ] } ], "usd_by_tier": { "reasoning": 0.039121, "volume": 0.0011062799999999999 }, "seconds": { "plan": 16.88, "generate": 9.27, "search": 11.75, "batch": 7.31, "total": 45.22 } }, "adjudication": { "target": "packaging.version:Version", "verdicts": [ { "signature": "P2|outcome|exc:packaging.version.InvalidVersion|ok|whitespace", "label": "likely-bug", "votes": { "likely-bug": 3 }, "rationale": "The fast path accepts a version with an internal space (e.g., '0 .0') because space is not in _NON_SIMPLE_VERSION_INDICATORS and strip() only removes leading/trailing whitespace. The base version correctly rejects it via regex. This is an unintended regression.", "evidence": [ "if _NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version):", "self._release = tuple(map(int, version.strip().split('.')))", "_NON_SIMPLE_VERSION_INDICATORS = frozenset('!+-ABCDEHILOPRSTVW_abcdehiloprstvw')", "If the ``version`` does not conform to PEP 440 in any way then this exception will be raised." ], "rejected": [], "reason": "" }, { "signature": "P2|outcome|exc:builtins.TypeError|exc:builtins.AttributeError|nested", "label": "likely-bug", "votes": { "likely-bug": 2, "needs-human": 1 }, "rationale": "The fast path accepts full-width digits (e.g., '１') because they are not in the ASCII-only indicator set, but then an AttributeError occurs (likely due to incomplete initialization). The base version raises TypeError. This change in exception type and acceptance of non-ASCII digits is unintended.", "evidence": [ "_NON_SIMPLE_VERSION_INDICATORS = frozenset('!+-ABCDEHILOPRSTVW_abcdehiloprstvw')", "if _NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version):", "self._release = tuple(map(int, version.strip().split('.')))" ], "rejected": [], "reason": "" }, { "signature": "P2|outcome|exc:packaging.version.InvalidVersion|ok|non-ascii", "label": "likely-bug", "votes": { "likely-bug": 3 }, "rationale": "The fast path accepts Arabic-Indic digits (e.g., '٠') because they are not in the indicator set, while the base version rejects them via the ASCII-only regex. This expands accepted characters unintentionally.", "evidence": [ "_NON_SIMPLE_VERSION_INDICATORS = frozenset('!+-ABCDEHILOPRSTVW_abcdehiloprstvw')", "if _NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version):", "self._release = tuple(map(int, version.strip().split('.')))", "If the ``version`` does not conform to PEP 440 in any way then this exception will be raised." ], "rejected": [], "reason": "" }, { "signature": "P2|outcome|exc:packaging.version.InvalidVersion|ok|non-ascii+whitespace", "label": "likely-bug", "votes": { "likely-bug": 3 }, "rationale": "The fast path accepts a version with an Arabic-Indic digit and an internal space ('١ .2') for the same reasons as C1 and C3. The base version rejects it. This is an unintended regression.", "evidence": [ "_NON_SIMPLE_VERSION_INDICATORS = frozenset('!+-ABCDEHILOPRSTVW_abcdehiloprstvw')", "if _NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version):", "self._release = tuple(map(int, version.strip().split('.')))", "If the ``version`` does not conform to PEP 440 in any way then this exception will be raised." ], "rejected": [], "reason": "" }, { "signature": "P2|outcome|exc:packaging.version.InvalidVersion|ok|long-digits+whitespace", "label": "intended", "votes": { "intended": 2, "needs-human": 1 }, "rationale": "The fast path is designed for all simple versions (only numbers and dots) without length limits. The base version's regex likely hit an internal recursion/length limit, causing InvalidVersion. The new behavior correctly accepts arbitrarily long simple versions per PEP 440.", "evidence": [ "# Fast path: If a version doesn't have one of these characters then", "# it is a simple version with just numbers and dots (e.g. 1.2.3).", "if _NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version):" ], "rejected": [], "reason": "" }, { "signature": "P2|outcome|exc:builtins.ValueError|exc:packaging.version.InvalidVersion|long-digits", "label": "intended", "votes": { "intended": 2, "needs-human": 1 }, "rationale": "The fast path wraps ValueError from int() into InvalidVersion, matching the library's documented exception for invalid versions. The base version let ValueError escape. This makes error handling consistent and deliberate.", "evidence": [ " self._release = tuple(map(int, version.strip().split('.')))", "except ValueError: raise InvalidVersion(f'Invalid version: {version!r}') from None", "# Fast path: If a version doesn't have one of these characters then", "if _NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version):" ], "rejected": [ "try:" ], "reason": "" } ], "samples": 3, "usd": 0.107429 }, "regression_tests": [ { "signature": "P2|outcome|exc:packaging.version.InvalidVersion|ok|whitespace", "name": "test_p2_outcome_0", "source": "def test_p2_outcome_0():\n \"\"\"Breakwater P2: base behaviour pinned (found by differential testing; label: likely-bug).\"\"\"\n import pytest\n from packaging.version import InvalidVersion, Version\n with pytest.raises(InvalidVersion) as excinfo:\n Version('0 .0')\n assert type(excinfo.value) is InvalidVersion # exact type: a subclass would be a behaviour change\n", "base": "pass", "head": "fail", "skipped": "", "verified": true }, { "signature": "P2|outcome|exc:builtins.TypeError|exc:builtins.AttributeError|nested", "name": "test_p2_outcome_1", "source": "def test_p2_outcome_1():\n \"\"\"Breakwater P2: base behaviour pinned (found by differential testing; label: likely-bug).\"\"\"\n import pytest\n from packaging.version import Version\n with pytest.raises(TypeError) as excinfo:\n Version(['１'])\n assert type(excinfo.value) is TypeError # exact type: a subclass would be a behaviour change\n", "base": "pass", "head": "error:AttributeError", "skipped": "", "verified": true }, { "signature": "P2|outcome|exc:packaging.version.InvalidVersion|ok|non-ascii", "name": "test_p2_outcome_2", "source": "def test_p2_outcome_2():\n \"\"\"Breakwater P2: base behaviour pinned (found by differential testing; label: likely-bug).\"\"\"\n import pytest\n from packaging.version import InvalidVersion, Version\n with pytest.raises(InvalidVersion) as excinfo:\n Version('٠')\n assert type(excinfo.value) is InvalidVersion # exact type: a subclass would be a behaviour change\n", "base": "pass", "head": "fail", "skipped": "", "verified": true }, { "signature": "P2|outcome|exc:packaging.version.InvalidVersion|ok|non-ascii+whitespace", "name": "test_p2_outcome_3", "source": "def test_p2_outcome_3():\n \"\"\"Breakwater P2: base behaviour pinned (found by differential testing; label: likely-bug).\"\"\"\n import pytest\n from packaging.version import InvalidVersion, Version\n with pytest.raises(InvalidVersion) as excinfo:\n Version('١ .2')\n assert type(excinfo.value) is InvalidVersion # exact type: a subclass would be a behaviour change\n", "base": "pass", "head": "fail", "skipped": "", "verified": true }, { "signature": "P2|outcome|exc:packaging.version.InvalidVersion|ok|long-digits+whitespace", "name": "test_p2_outcome_4", "source": "", "base": "not run", "head": "not run", "skipped": "adjudicated intended: no test pins the old behaviour", "verified": false }, { "signature": "P2|outcome|exc:builtins.ValueError|exc:packaging.version.InvalidVersion|long-digits", "name": "test_p2_outcome_5", "source": "", "base": "not run", "head": "not run", "skipped": "adjudicated intended: no test pins the old behaviour", "verified": false } ], "perf": { "run_id": "e780ff68654f", "target": "packaging.version:Version", "image": "dbe8dafe-78c4-4fc8-b8c2-a5adaad2ed49", "backend": "contree", "families": [ { "id": "F1", "kind": "suspected_slowdown", "family": "Long release segment (many dot-separated numbers) ending with a pre‑release marker (e.g. \"1.1.1…a1\"). The new fast‑path scans the whole string looking for indicator characters before falling back to the regex, so the disjointness check walks the entire long numeric prefix before finding the trailing 'a'.", "why": "The added `_NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version)` iterates over every character of the version string. In this family the only indicator character ('a') appears at the very end, forcing a full O(N) scan before the regex is even attempted. The old version went straight to the compiled regex, which runs in C and does not have this extra Python‑level loop.", "size_meaning": "Number of release components (n). Cost grows linearly with n.", "make_source": "def make(n):\n # Build a release with n components \"1.1.…\" and append a pre‑release marker\n release = '.'.join(['1'] * n)\n version = f'{release}a1'\n return [[version]]", "example_args": [ [ "1.1.1.1.1.1.1.1.1.1a1" ] ], "origin": "plan", "screen_ratio": 1.0798088129260297, "valid_fraction": 1.0, "error": null }, { "id": "F2", "kind": "claimed_speedup", "family": "many numeric segments, no special characters", "why": "Fast‑path is taken but it does a Python‑level split+map while the old code runs a single compiled regex; for very long simple versions the Python loop can be slower.", "size_meaning": "number of dot‑separated numeric segments", "make_source": "def make(n):\n seg = '.'.join(['1'] * n)\n return [(seg,)]", "example_args": [], "origin": "plan", "screen_ratio": 0.621291554571564, "valid_fraction": 1.0, "error": null }, { "id": "F3", "kind": "claimed_speedup", "family": "Simple numeric versions (e.g. \"1.2.3\") – the fast‑path added by the change.", "why": "The new code checks that the version string contains none of the indicator characters; for pure dotted integers this test succeeds and the version is parsed by a cheap split‑and‑map, avoiding the heavy regex.", "size_meaning": "Number of dot‑separated integer segments (release length).", "make_source": "def make(n):\n # n >= 1 : build a version like \"1.2.3...\" with n segments\n parts = [str(i+1) for i in range(n)]\n return [[\".\".join(parts)]]", "example_args": [ [ "1" ], [ "1.2" ], [ "1.2.3" ], [ "1.2.3.4" ] ], "origin": "plan", "screen_ratio": 0.6499593630560818, "valid_fraction": 1.0, "error": null }, { "id": "F4", "kind": "suspected_slowdown", "family": "Long release segment ending with a development release marker (\"dev\"). The letters d, e, v are all in the indicator set, but they appear only at the end of a long numeric prefix.", "why": "Same reasoning as the pre‑release family: the disjointness check must examine every character of the long numeric prefix before encountering the first indicator character ('d').", "size_meaning": "Number of release components (n). Cost grows linearly with n.", "make_source": "def make(n):\n release = '.'.join(['1'] * n)\n version = f'{release}dev1'\n return [[version]]", "example_args": [ [ "1.1.1.1.1.1.1.1.1.1dev1" ] ], "origin": "plan", "screen_ratio": 1.0769110145877179, "valid_fraction": 1.0, "error": null }, { "id": "F5", "kind": "suspected_slowdown", "family": "many numeric segments followed by a pre‑release marker (e.g. 'a1')", "why": "The fast‑path set‑disjoint scan walks the whole string before finding the trailing 'a', then falls back to the regex; the base version only runs the regex.", "size_meaning": "number of dot‑separated numeric segments before the pre‑release marker", "make_source": "def make(n):\n base = '.'.join(['1'] * n)\n version = base + 'a1'\n return [(version,)]", "example_args": [], "origin": "plan", "screen_ratio": 1.0798088129260297, "valid_fraction": 1.0, "error": null }, { "id": "F6", "kind": "suspected_slowdown", "family": "Pre‑release versions using the \"a\" (alpha) marker (e.g. \"1.0a1\").", "why": "The string contains the letter \"a\", which is in _NON_SIMPLE_VERSION_INDICATORS. The fast‑path test scans the whole string, finds the indicator, then falls back to the full regex – extra work compared with the old code that went straight to the regex.", "size_meaning": "Length of the numeric pre‑release suffix (n).", "make_source": "def make(n):\n # produce versions like \"1.0a1\", \"1.0a2\", … up to n\n return [[f\"1.0a{i}\"] for i in range(1, n+1)]", "example_args": [ [ "1.0a1" ], [ "1.0a2" ], [ "1.0a10" ] ], "origin": "plan", "screen_ratio": 1.0344463347057826, "valid_fraction": 1.0, "error": null }, { "id": "R1", "kind": "suspected_slowdown", "family": "Each numeric chunk is an ascending sequence starting at '0'", "why": "The fast‑path’s `isdisjoint` test iterates over every character. For a long dotted release the string length grows with n, so the extra scan adds linear overhead before the (already linear) regex match.", "size_meaning": "Number of dotted release segments (plus the trailing pre‑release).", "make_source": "\ndef make(n):\n chunks = []\n start_ord = ord('0')\n for i in range(n):\n s = ''\n cur = start_ord\n while len(s) < i:\n s += chr(cur)\n cur += 1\n if cur > ord('9'):\n cur = ord('0')\n chunks.append(s)\n version = '.'.join(chunks) + 'rc1'\n return [(version,)]", "example_args": [], "origin": "archive", "screen_ratio": 2.2444239666002184, "valid_fraction": 0.0, "error": "ladder inputs exceed 2000000 chars at n=4096; ladder stops here" }, { "id": "R2", "kind": "suspected_slowdown", "family": "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.", "why": "Even though the version is invalid, the extra disjoint check runs; the regex then fails. This is the single allowed invalid family.", "size_meaning": "Number of dotted segments before the malformed tail.", "make_source": "def make(n):\n # \"1.\" repeated n times then an alphabetic tail – not a valid PEP‑440 version\n version = \"1.\" * n + \"x\"\n return [(version,)]", "example_args": [], "origin": "archive", "screen_ratio": 1.9962265393263607, "valid_fraction": 0.0, "error": null }, { "id": "R3", "kind": "suspected_slowdown", "family": "invalid strings that look simple (only digits and dots) but contain a non‑numeric segment, e.g. \"1.2.x\"", "why": "The indicator set is disjoint, so the fast path is entered. The code then executes `tuple(map(int, version.strip().split('.')))`, which raises `ValueError` on the bad segment; the exception is caught and re‑raised as `InvalidVersion`. Exception handling is considerably slower than the original regex‑only failure path.", "size_meaning": "n = number of leading numeric segments before the bad segment; larger n makes the split and the failed `int` conversion traverse more items before the exception.", "make_source": "def make(n):\n # build \"1.1.1....1.x\" with n numeric parts then a non‑numeric \"x\"\n good = \".\".join(\"1\" for _ in range(n))\n version = f\"{good}.x\"\n return [[version]]", "example_args": [], "origin": "archive", "screen_ratio": 1.9962265393263607, "valid_fraction": 0.0, "error": null }, { "id": "R4", "kind": "suspected_slowdown", "family": "Pre-release label changed from 'c5' to 'alpha.1'", "why": "The fast‑path’s `isdisjoint` test iterates over every character. For a long dotted release the string length grows with n, so the extra scan adds linear overhead before the (already linear) regex match.", "size_meaning": "Number of dotted release segments (plus the trailing pre‑release).", "make_source": "\ndef make(n):\n chunks = []\n for i in range(1, n+1):\n chunks.append('9' * i)\n version = '.'.join(chunks) + '-alpha.1'\n return [(version,)]", "example_args": [], "origin": "archive", "screen_ratio": 1.289682789117718, "valid_fraction": 1.0, "error": "ladder inputs exceed 2000000 chars at n=4096; ladder stops here" }, { "id": "R4.1", "kind": "suspected_slowdown", "family": "Pre-release label variation", "why": "The fast‑path’s `isdisjoint` test iterates over every character. For a long dotted release the string length grows with n, so the extra scan adds linear overhead before the (already linear) regex match.", "size_meaning": "Number of dotted release segments (plus the trailing pre‑release).", "make_source": "def make(n):\n base_chunks = []\n for i in range(1, n+1):\n base_chunks.append('9'*i)\n core_version = \".\".join(base_chunks)\n prefix_labels = [\"dev\", \"rc\", \"post\"]\n versions = []\n # Use round-robin assignment across small set\n for idx, lbl in enumerate(prefix_labels):\n repeated = lbl*((idx%2)+1) # dev/dev/ rc/rc etc.\n vcore = f\"{core_version}-{repeated}\"\n versions.append([vcore])\n return versions", "example_args": [], "origin": "expand:R4", "screen_ratio": 1.3482088878482477, "valid_fraction": 0.6666666666666666, "error": "ladder inputs exceed 2000000 chars at n=4096; ladder stops here" }, { "id": "R4.2", "kind": "suspected_slowdown", "family": "Trailing numeric sub-label added", "why": "The fast‑path’s `isdisjoint` test iterates over every character. For a long dotted release the string length grows with n, so the extra scan adds linear overhead before the (already linear) regex match.", "size_meaning": "Number of dotted release segments (plus the trailing pre‑release).", "make_source": "def make(n):\n segs = ['9'*i for i in range(1,n+1)]\n full_base = \".\".join(segs)\n suffixes = ['-alpha', '-beta.0', '-gamma']\n outs = []\n for s in suffixes:\n v = full_base + s\n outs.append([v])\n return outs", "example_args": [], "origin": "expand:R4", "screen_ratio": 1.3656331099059376, "valid_fraction": 0.6666666666666666, "error": "ladder inputs exceed 2000000 chars at n=4096; ladder stops here" }, { "id": "R4.3", "kind": "suspected_slowdown", "family": "Long postfix via build metadata increase", "why": "The fast‑path’s `isdisjoint` test iterates over every character. For a long dotted release the string length grows with n, so the extra scan adds linear overhead before the (already linear) regex match.", "size_meaning": "Number of dotted release segments (plus the trailing pre‑release).", "make_source": "def make(n):\n dots = \".\".join(['7'*k for k in range(1, n//2+1)])\n tail_build_ids = '+build.'+\"0123456789ABCDEF\"*(n//4)\n out = []\n # Alternate label variations at end as well\n labels=[\"-dev\",\"-rc\",\"-alpha\"]\n labs_iter=iter(labels)*max(1,(n//1))\n lab=\"\"\n try:\n lab=next(labs_iter)\n except StopIteration:\n pass\n final=f\"{dots}{lab}{tail_build_ids}\"\n out.append([final])\n return out", "example_args": [], "origin": "expand:R4", "screen_ratio": null, "valid_fraction": null, "error": "make(2): TypeError: unsupported operand type(s) for *: 'list_iterator' and 'int'" }, { "id": "F1.1", "kind": "suspected_slowdown", "family": "Long major.minor.patch... sequence followed by development release suffix (.dev)", "why": "The added `_NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version)` iterates over every character of the version string. In this family the only indicator character ('a') appears at the very end, forcing a full O(N) scan before the regex is even attempted. The old version went straight to the compiled regex, which runs in C and does not have this extra Python‑level loop.", "size_meaning": "Number of release components (n). Cost grows linearly with n.", "make_source": "", "example_args": [ [ "1.1.1.1.1.1.1.1.1.1a1" ] ], "origin": "expand:F1", "screen_ratio": null, "valid_fraction": null, "error": "make(n) rejected: code must assign `strategy`" }, { "id": "F1.2", "kind": "suspected_slowdown", "family": "Repeated short segments creating long strings without early indicators", "why": "The added `_NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version)` iterates over every character of the version string. In this family the only indicator character ('a') appears at the very end, forcing a full O(N) scan before the regex is even attempted. The old version went straight to the compiled regex, which runs in C and does not have this extra Python‑level loop.", "size_meaning": "Number of release components (n). Cost grows linearly with n.", "make_source": "", "example_args": [ [ "1.1.1.1.1.1.1.1.1.1a1" ] ], "origin": "expand:F1", "screen_ratio": null, "valid_fraction": null, "error": "make(n) rejected: code must assign `strategy`" }, { "id": "F1.3", "kind": "suspected_slowdown", "family": "Numeric-only versions pushing into post-release parsing territory", "why": "The added `_NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version)` iterates over every character of the version string. In this family the only indicator character ('a') appears at the very end, forcing a full O(N) scan before the regex is even attempted. The old version went straight to the compiled regex, which runs in C and does not have this extra Python‑level loop.", "size_meaning": "Number of release components (n). Cost grows linearly with n.", "make_source": "", "example_args": [ [ "1.1.1.1.1.1.1.1.1.1a1" ] ], "origin": "expand:F1", "screen_ratio": null, "valid_fraction": null, "error": "make(n) rejected: code must assign `strategy`" } ], "findings": [ { "family_id": "R4.2", "kind": "suspected_slowdown", "family": "Trailing numeric sub-label added", "why": "The fast‑path’s `isdisjoint` test iterates over every character. For a long dotted release the string length grows with n, so the extra scan adds linear overhead before the (already linear) regex match.", "origin": "expand:R4", "screen_ratio": 1.3656331099059376, "valid_fraction": 0.6666666666666666, "ladder": [ { "n": 2, "base_ir": 25682.968333333334, "head_ir": 26856.995833333334, "input_chars": 14.333333333333334, "valid_fraction": 0.6666666666666666, "ratio": 1.045712297922988, "judged": true }, { "n": 4, "base_ir": 28643.96416666667, "head_ir": 30887.236666666668, "input_chars": 23.333333333333332, "valid_fraction": 0.6666666666666666, "ratio": 1.0783157138078856, "judged": true }, { "n": 16, "base_ir": 50799.5, "head_ir": 69373.47916666667, "input_chars": 161.33333333333334, "valid_fraction": 0.6666666666666666, "ratio": 1.3656331099059376, "judged": true }, { "n": 64, "base_ir": 215453.0, "head_ir": 467509.0, "input_chars": 2153.3333333333335, "valid_fraction": 0.6666666666666666, "ratio": 2.169888560382079, "judged": true }, { "n": 256, "base_ir": 2229984.8333333335, "head_ir": 6111820.0, "input_chars": 33161.333333333336, "valid_fraction": 0.6666666666666666, "ratio": 2.740745097743191, "judged": true }, { "n": 1024, "base_ir": null, "head_ir": null, "input_chars": 525833.3333333334, "valid_fraction": null, "ratio": null, "judged": false } ], "slope_base": 0.5651374169299807, "slope_head": 0.696726426425837, "top_inputs": [], "error": "ladder inputs exceed 2000000 chars at n=4096; ladder stops here", "verdict": "slower", "worst_ratio": 2.740745097743191, "worst_search": null }, { "family_id": "R4.1", "kind": "suspected_slowdown", "family": "Pre-release label variation", "why": "The fast‑path’s `isdisjoint` test iterates over every character. For a long dotted release the string length grows with n, so the extra scan adds linear overhead before the (already linear) regex match.", "origin": "expand:R4", "screen_ratio": 1.3482088878482477, "valid_fraction": 0.6666666666666666, "ladder": [ { "n": 2, "base_ir": 27204.31, "head_ir": 28378.3375, "input_chars": 12.666666666666666, "valid_fraction": 0.6666666666666666, "ratio": 1.043155937423151, "judged": true }, { "n": 4, "base_ir": 30161.234166666665, "head_ir": 32404.029166666667, "input_chars": 21.666666666666668, "valid_fraction": 0.6666666666666666, "ratio": 1.0743601865761407, "judged": true }, { "n": 16, "base_ir": 53246.99593495935, "head_ir": 71788.0731707317, "input_chars": 159.66666666666666, "valid_fraction": 0.6666666666666666, "ratio": 1.3482088878482477, "judged": true }, { "n": 64, "base_ir": 217340.66666666666, "head_ir": 468978.3333333333, "input_chars": 2151.6666666666665, "valid_fraction": 0.6666666666666666, "ratio": 2.1578029575689164, "judged": true }, { "n": 256, "base_ir": 2232203.1666666665, "head_ir": 6113651.666666667, "input_chars": 33159.666666666664, "valid_fraction": 0.6666666666666666, "ratio": 2.7388419468090537, "judged": true }, { "n": 1024, "base_ir": null, "head_ir": null, "input_chars": 525831.6666666666, "valid_fraction": null, "ratio": null, "judged": false } ], "slope_base": 0.5486294820830394, "slope_head": 0.6786813421305725, "top_inputs": [], "error": "ladder inputs exceed 2000000 chars at n=4096; ladder stops here", "verdict": "slower", "worst_ratio": 2.7388419468090537, "worst_search": null }, { "family_id": "R4", "kind": "suspected_slowdown", "family": "Pre-release label changed from 'c5' to 'alpha.1'", "why": "The fast‑path’s `isdisjoint` test iterates over every character. For a long dotted release the string length grows with n, so the extra scan adds linear overhead before the (already linear) regex match.", "origin": "archive", "screen_ratio": 1.289682789117718, "valid_fraction": 1.0, "ladder": [ { "n": 2, "base_ir": 31317.385, "head_ir": 32473.44, "input_chars": 16.0, "valid_fraction": 1.0, "ratio": 1.0369141612558008, "judged": true }, { "n": 4, "base_ir": 35208.7125, "head_ir": 37433.78, "input_chars": 25.0, "valid_fraction": 1.0, "ratio": 1.0631965028542296, "judged": true }, { "n": 16, "base_ir": 63767.31404958678, "head_ir": 82239.60743801652, "input_chars": 163.0, "valid_fraction": 1.0, "ratio": 1.289682789117718, "judged": true }, { "n": 64, "base_ir": 257563.22222222222, "head_ir": 509709.22222222225, "input_chars": 2155.0, "valid_fraction": 1.0, "ratio": 1.9789674077863948, "judged": true }, { "n": 256, "base_ir": 2564072.5, "head_ir": 6444799.5, "input_chars": 33163.0, "valid_fraction": 1.0, "ratio": 2.513501275802459, "judged": true }, { "n": 1024, "base_ir": 53301546.25, "head_ir": 114830442.5, "input_chars": 525835.0, "valid_fraction": 1.0, "ratio": 2.1543548091721636, "judged": true } ], "slope_base": 0.6947278271762642, "slope_head": 0.7798258939860435, "top_inputs": [], "error": "ladder inputs exceed 2000000 chars at n=4096; ladder stops here", "verdict": "slower", "worst_ratio": 2.513501275802459, "worst_search": null }, { "family_id": "F1", "kind": "suspected_slowdown", "family": "Long release segment (many dot-separated numbers) ending with a pre‑release marker (e.g. \"1.1.1…a1\"). The new fast‑path scans the whole string looking for indicator characters before falling back to the regex, so the disjointness check walks the entire long numeric prefix before finding the trailing 'a'.", "why": "The added `_NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version)` iterates over every character of the version string. In this family the only indicator character ('a') appears at the very end, forcing a full O(N) scan before the regex is even attempted. The old version went straight to the compiled regex, which runs in C and does not have this extra Python‑level loop.", "origin": "plan", "screen_ratio": 1.0798088129260297, "valid_fraction": 1.0, "ladder": [ { "n": 2, "base_ir": 30775.435, "head_ir": 31796.49, "input_chars": 9.0, "valid_fraction": 1.0, "ratio": 1.0331775976521533, "judged": true }, { "n": 4, "base_ir": 33900.0725, "head_ir": 35387.1525, "input_chars": 13.0, "valid_fraction": 1.0, "ratio": 1.0438665728517245, "judged": true }, { "n": 16, "base_ir": 53666.285, "head_ir": 57949.3275, "input_chars": 37.0, "valid_fraction": 1.0, "ratio": 1.0798088129260297, "judged": true }, { "n": 64, "base_ir": 133264.83783783784, "head_ir": 148723.83783783784, "input_chars": 133.0, "valid_fraction": 1.0, "ratio": 1.1160020921558556, "judged": true }, { "n": 256, "base_ir": 451712.1710526316, "head_ir": 512741.9605263158, "input_chars": 517.0, "valid_fraction": 1.0, "ratio": 1.1351076933160016, "judged": true }, { "n": 1024, "base_ir": 1703893.3333333333, "head_ir": 1942560.6666666667, "input_chars": 2053.0, "valid_fraction": 1.0, "ratio": 1.1400717572304997, "judged": true }, { "n": 4096, "base_ir": 6920152.75, "head_ir": 7883374.0, "input_chars": 8197.0, "valid_fraction": 1.0, "ratio": 1.139190749799562, "judged": true } ], "slope_base": 0.8010837442523397, "slope_head": 0.8161445634827589, "top_inputs": [ { "args": [ "1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1a1" ], "cpu_ratio": 1.143, "base_ir": 221085.6325301205, "head_ir": 248857.4156626506, "ir_ratio": 1.125615503887375, "outcome": "ok" }, { "args": [ "1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1a1" ], "cpu_ratio": 1.141, "base_ir": 345590.06862745096, "head_ir": 390142.06862745096, "ir_ratio": 1.128915741638477, "outcome": "ok" } ], "error": null, "verdict": "slower", "worst_ratio": 1.1400717572304997, "worst_search": { "args": [ "1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1a1" ], "cpu_ratio": 1.141, "base_ir": 345590.06862745096, "head_ir": 390142.06862745096, "ir_ratio": 1.128915741638477, "outcome": "ok" } }, { "family_id": "F2", "kind": "claimed_speedup", "family": "many numeric segments, no special characters", "why": "Fast‑path is taken but it does a Python‑level split+map while the old code runs a single compiled regex; for very long simple versions the Python loop can be slower.", "origin": "plan", "screen_ratio": 0.621291554571564, "valid_fraction": 1.0, "ladder": [ { "n": 2, "base_ir": 27346.935, "head_ir": 10298.125, "input_chars": 7.0, "valid_fraction": 1.0, "ratio": 0.37657327960153486, "judged": true }, { "n": 4, "base_ir": 30475.5475, "head_ir": 13144.7625, "input_chars": 11.0, "valid_fraction": 1.0, "ratio": 0.4313216194065094, "judged": true }, { "n": 16, "base_ir": 50230.785, "head_ir": 31207.9625, "input_chars": 35.0, "valid_fraction": 1.0, "ratio": 0.621291554571564, "judged": true }, { "n": 64, "base_ir": 129771.61333333333, "head_ir": 103975.42, "input_chars": 131.0, "valid_fraction": 1.0, "ratio": 0.8012185202084771, "judged": true }, { "n": 256, "base_ir": 447861.1447368421, "head_ir": 394949.59210526315, "input_chars": 515.0, "valid_fraction": 1.0, "ratio": 0.8818572380002531, "judged": true }, { "n": 1024, "base_ir": 1699074.111111111, "head_ir": 1535929.111111111, "input_chars": 2051.0, "valid_fraction": 1.0, "ratio": 0.9039800565889906, "judged": true }, { "n": 4096, "base_ir": 6909990.75, "head_ir": 6312715.25, "input_chars": 8195.0, "valid_fraction": 1.0, "ratio": 0.9135634877658845, "judged": true } ], "slope_base": 0.7915398940278904, "slope_head": 0.9173146369601095, "top_inputs": [], "error": null, "verdict": "faster", "worst_ratio": 0.9135634877658845, "worst_search": null } ], "seconds": { "plan": 15.28, "screen": 147.94, "full": 146.29, "total": 309.51 } }, "usd_by_tier": { "reasoning": 0.18197000000000002, "volume": 0.0014064, "proposer": 0.00075 }, "sandbox": { "backend": "contree", "image": "dbe8dafe-78c4-4fc8-b8c2-a5adaad2ed49", "runs": 358, "cpu_s": 1165.35, "cost_usd": 11.924752 } }