{ "run_id": "c1a7799be95f", "repo": "https://github.com/pypa/packaging", "base": "59f183fe90da403e41eef339ce9088bda0fe4cd3", "head": "61967cca278dc51389b8973ba65bbbf23eaa3eda", "target": "packaging.version:Version", "title": "perf: fast path for simple versions (intermediate commit 61967cca)", "provider": "tokenfactory", "semantic": { "run_id": "c1a7799be95f", "repo": "https://github.com/pypa/packaging", "base": "59f183fe90da403e41eef339ce9088bda0fe4cd3", "head": "61967cca278dc51389b8973ba65bbbf23eaa3eda", "target": "packaging.version:Version", "image": "bw-pair:348e2d05c100a5f9", "backend": "docker", "attacks": [ { "id": "A1", "routing_condition": "Version.__init__ receives a string that contains only characters not present in _NON_SIMPLE_VERSION_INDICATORS (e.g. spaces, tabs, newlines). The fast‑path’s `if _NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version):` evaluates to True, `version.strip()` removes the surrounding whitespace, the split‑and‑int conversion succeeds, and the constructor returns early.", "assumption": "The fast‑path assumes the version string contains only ASCII digits and dots, so it strips leading/trailing whitespace before parsing.", "why_it_breaks": "base: The original regex‑based parser (`_regex.fullmatch(version)`) is anchored (`^…$`) and does not allow surrounding whitespace, so it raises `InvalidVersion`.; head: The new fast‑path accepts the stripped string, builds a Version object with epoch 0, release tuple, and no pre/post/dev/local parts, and returns normally.", "input_family": "Version strings that are a valid simple numeric dotted version surrounded by leading/trailing ASCII whitespace.", "example_args": [ [ " 1.2.3 " ], [ "\t1.0.0\n" ] ], "difference": "accepts what base rejects" }, { "id": "A2", "routing_condition": "Version string contains only digits and '.' (e.g. \"1.0.0\"), so _NON_SIMPLE_VERSION_INDICATORS.isdisjoint() is true and the fast‑path executes.", "assumption": "The fast‑path assumes a simple numeric version never has trailing zero components, so it skips the normal trailing‑zero stripping logic.", "why_it_breaks": "base: Version(\"1.0.0\").release == (1,) and str(Version(\"1.0.0\")) == \"1.0\".; head: Version(\"1.0.0\").release == (1, 0, 0) and str(Version(\"1.0.0\")) == \"1.0.0\".", "input_family": "numeric dot‑only versions with trailing zero components", "example_args": [ [ "1.0.0" ], [ "2.0.0.0" ], [ "0.0" ], [ "5.0.0.0.0" ] ], "difference": "different value or string form" }, { "id": "A3", "routing_condition": "Version string contains only digits and dots (no indicator characters) but has leading/trailing whitespace, so `_NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version)` is true and the fast‑path is taken.", "assumption": "The fast‑path assumes that surrounding whitespace is harmless because it strips the string before parsing, while the original regex validates the raw string.", "why_it_breaks": "base: Version(\" 1.2.3 \") raises `InvalidVersion` because the original regex does a fullmatch on the raw string containing spaces.; head: Version(\" 1.2.3 \") is accepted; the fast‑path strips whitespace, splits on '.', converts each part to int, stores epoch=0, pre/post/dev/local=None and returns a valid Version object.", "input_family": "whitespace‑padded numeric version", "example_args": [ [ " 1.2.3 " ], [ "\t1.2.3\n" ] ], "difference": "accepts what base rejects" }, { "id": "A4", "routing_condition": "Version.__init__ receives a string that consists solely of characters outside `_NON_SIMPLE_VERSION_INDICATORS` (e.g. IDEOGRAPHIC SPACE U+3000). The set‑disjoint test passes, `version.strip()` removes the Unicode whitespace, the dotted numeric conversion succeeds, and the constructor returns early.", "assumption": "The fast‑path assumes the version string contains only ASCII digits and dots, so it strips any Unicode whitespace characters before parsing.", "why_it_breaks": "base: The original regex does not recognise Unicode whitespace as part of the version pattern, so `fullmatch` fails and `InvalidVersion` is raised.; head: The fast‑path creates a Version object from the stripped numeric dotted string, treating it as a valid simple version.", "input_family": "Version strings that are a valid simple numeric dotted version surrounded by leading/trailing Unicode whitespace.", "example_args": [ [ "　 1.2.3 　" ] ], "difference": "accepts what base rejects" }, { "id": "A5", "routing_condition": "Version string consists solely of digits and '.' and ends with one or more '.0' components (e.g. \"3.2.0\").", "assumption": "The fast‑path assumes numeric dot‑only versions are already in normalized form, so it omits the trailing‑zero stripping step.", "why_it_breaks": "base: Version(\"3.2.0\").release == (3, 2) and str(Version(\"3.2.0\")) == \"3.2\".; head: Version(\"3.2.0\").release == (3, 2, 0) and str(Version(\"3.2.0\")) == \"3.2.0\".", "input_family": "numeric dot‑only versions ending with one or more zero components", "example_args": [ [ "3.2.0" ], [ "10.0" ], [ "0.0.0" ] ], "difference": "different value or string form" } ], "strategies": [ { "id": "A1/s1", "attack": "A1", "valid": true, "error": "TypeError: characters() got an unexpected keyword argument 'include_categories'", "examples": 0, "findings": 0, "source": "strategy = st.tuples(\n st.text(\n alphabet=st.characters(\n blacklist_categories=(\"Cc\",),\n include_categories=(\"Nd\", \"L\", \"Z\", \"Ps\", \"Pe\", \"Pd\"),\n ),\n min_size=1,\n max_size=3,\n ),\n st.text(\n alphabet=st.characters(\n blacklist_categories=(\"Cc\",),\n include_categories=(\"Ps\", \"Pe\", \"Pd\"),\n ),\n min_size=0,\n max_size=3,\n ),\n st.text(\n alphabet=st.characters(\n blacklist_categories=(\"Cc\",),\n include_categories=(\"Ps\", \"Pe\", \"Pd\"),\n ),\n min_size=0,\n max_size=3,\n ),\n).map(lambda args: \"\".join(args))" }, { "id": "A1/s2", "attack": "A1", "valid": true, "error": "HypothesisException: Using example() inside a strategy definition is a bad idea. Instead consider using hypothesis.strategies.builds() or @hypothesis.strategies.composite to define your strategy. See https://hypothesis.readthedocs.io/en/latest/reference/strategies.html#hypothesis.strategies.builds or https://hypothesis.readthedocs.io/en/latest/reference/strategies.html#hypothesis.strategies.composite for more details.", "examples": 0, "findings": 0, "source": "strategy = st.tuples(\n st.text(\n alphabet=string.digits + \".\",\n min_size=1,\n max_size=5,\n ).map(lambda s: \" \" * st.integers(min_value=0, max_value=3).example() + s + \" \" * st.integers(min_value=0, max_value=3)),\n)" }, { "id": "A1/s3", "attack": "A1", "valid": false, "error": "syntax error: invalid syntax (line 1)", "examples": 0, "findings": 0, "source": "st.lists(st.one_of(st.integers(min_value=0, max_value=99), st.text(alphabet=string.digits+\".\", min_size=1, max_size=5)), min_size=1, max_size=3) st.text(alphabet=string.whitespace, min_size=1) st.just(\" \").map(lambda _: \" 1.2.3 \")" }, { "id": "A1/s4", "attack": "A1", "valid": true, "error": null, "examples": 300, "findings": 0, "source": "strategy = st.tuples(\n st.text(\n alphabet=string.ascii_letters + string.digits + \" \\t\\n\\r\",\n min_size=1,\n max_size=30,\n ).map(lambda s: s.strip(\" \\t\\n\\r\")),\n st.just(\".\"),\n)" }, { "id": "A2/s1", "attack": "A2", "valid": false, "error": "code must assign `strategy`", "examples": 0, "findings": 0, "source": "# Generate numeric dot-only version strings with trailing zeros.\n# Covers the fast-path trigger: versions consisting solely of digits and dots,\n# where the fast path sets release=(1,) while the normal logic keeps all components.\nst.text(st.characters(alphabet=string.digits + \".\", min_size=1, max_size=64))" }, { "id": "A2/s2", "attack": "A2", "valid": true, "error": null, "examples": 5, "findings": 0, "source": "strategy = st.lists(\n st.just(\".\").map(lambda _: st.integers(min_value=0, max_value=999)),\n min_size=1,\n max_size=5,\n).map(lambda parts: \".\".join(str(p) for p in parts))" }, { "id": "A2/s3", "attack": "A2", "valid": false, "error": "syntax error: unexpected indent (line 2)", "examples": 0, "findings": 0, "source": "# strategy for A2: numeric dot-only versions with trailing zeros\n strategy = st.lists(\n st.integers(min_value=0, max_value=999),\n min_size=1,\n max_size=5\n ).map(lambda parts: \".\".join(str(p) for p in parts))" }, { "id": "A2/s4", "attack": "A2", "valid": true, "error": null, "examples": 300, "findings": 0, "source": "strategy = st.tuples(\n st.integers(min_value=0, max_value=999),\n st.text(\n alphabet=string.digits + \".\",\n min_size=1,\n max_size=5,\n ).filter(lambda s: s.count(\".\") >= 1),\n)" }, { "id": "A3/s1", "attack": "A3", "valid": false, "error": "code must assign `strategy`", "examples": 0, "findings": 0, "source": "st.tuples(st.text(alphabet=string.digits+\". \", min_size=1, max_size=1).map(str.strip or (lambda x: x)), st.text(alphabet=string.whitespace, min_size=1, max_size=1))" }, { "id": "A3/s2", "attack": "A3", "valid": true, "error": "HypothesisException: Using example() inside a strategy definition is a bad idea. Instead consider using hypothesis.strategies.builds() or @hypothesis.strategies.composite to define your strategy. See https://hypothesis.readthedocs.io/en/latest/reference/strategies.html#hypothesis.strategies.builds or https://hypothesis.readthedocs.io/en/latest/reference/strategies.html#hypothesis.strategies.composite for more details.", "examples": 0, "findings": 0, "source": "strategy = st.lists(\n st.text(alphabet=st.characters(blacklist_categories=(\"Cc\",)), min_size=1, max_size=5),\n min_size=1,\n max_size=1,\n).map(lambda lst: \" \" * st.just(2).example() + lst[0] + \" \" * st.just(2).example() if lst else \"\")" }, { "id": "A3/s3", "attack": "A3", "valid": true, "error": null, "examples": 449, "findings": 1, "source": "strategy = st.lists(\n st.one_of(st.text(alphabet=string.digits + \".\", min_size=1, max_size=20), st.just(\" \")),\n min_size=2,\n max_size=3,\n).map(lambda parts: \" \" + parts[0] + \" \" if len(parts) == 2 else \" \".join(parts))" }, { "id": "A3/s4", "attack": "A3", "valid": true, "error": "TypeError: characters() got an unexpected keyword argument 'whitespace'", "examples": 0, "findings": 0, "source": "strategy = st.lists(\n st.one_of(\n st.text(st.characters(whitespace=True, min_codepoint=0, max_codepoint=0x10FFFF), min_size=1, max_size=30),\n st.just(\"\"),\n ),\n min_size=1,\n max_size=1,\n).map(lambda items: tuple(\" \" + \"\".join(items) + \" \" for _ in range(1)) if False else \"\".join(items))," }, { "id": "A4/s1", "attack": "A4", "valid": true, "error": "TypeError: sequence item 0: expected str instance, int found", "examples": 1, "findings": 0, "source": "strategy = st.lists(\n st.one_of(\n st.text(alphabet=st.characters(whitelist_categories=(\"Zs\",)), min_size=1, max_size=10),\n st.text(alphabet=st.characters(blacklist_characters=\" \\t\\n\\r\"), min_size=1, max_size=10),\n st.integers(min_value=0, max_value=999),\n st.just(\".\"),\n st.just(\"\"),\n ),\n min_size=1, max_size=5\n).map(\"\".join).flatmap(lambda s: st.just(\"\\u3000\\u3000\" + s + \"\\u3000\\u3000\"))" }, { "id": "A4/s2", "attack": "A4", "valid": true, "error": "TypeError: characters() got an unexpected keyword argument 'alphabet'", "examples": 0, "findings": 0, "source": "strategy = st.lists(\n st.characters(\n alphabet=string.whitespace,\n min_codepoint=0x2000,\n max_codepoint=0x200F,\n ),\n min_size=0,\n max_size=5,\n).map(''.join) | st.just(\"\")\n@st.composite\ndef _version_str(draw):\n inner = st.text(\n alphabet=st.characters(whitelist_categories=None, blacklist_characters='!+-ABCDEHILOPRSTVW_abcdehiloprstvw'),\n min_size=1,\n max_size=4,\n ).example(\"1.2.3\")\n return draw(st.text(alphabet=st.characters(whitelist_categories=None), min_size=0, max_size=8)) + inner + draw(st.text(alphabet=st.characters(whitelist_categories=None), min_size=0, max_size=8))\n\nstrategy = st.tuples(_version_str())" }, { "id": "A4/s3", "attack": "A4", "valid": true, "error": null, "examples": 396, "findings": 1, "source": "strategy = st.tuples(\n st.text(alphabet=string.whitespace + \"0123456789.\", min_size=1, max_size=50),\n st.integers(min_value=0, max_value=999)\n).map(lambda args: f\"{args[0]}{args[1]}\" if args[1] else args[0]) if False else None or st.text(alphabet=string.whitespace + \"0123456789.\", min_size=1, max_size=50).map(lambda s: s.strip(string.whitespace).strip() if s.strip(string.whitespace).strip() else s) # noqa: E501\n\n# Simplified for the prompt constraint\nstrategy = st.text(alphabet=string.whitespace + \"0123456789.\", min_size=1, max_size=50).map(lambda s: f\"{s.strip(string.whitespace)}\")" }, { "id": "A4/s4", "attack": "A4", "valid": true, "error": "TypeError: unsupported operand type(s) for +: 'LazyStrategy' and 'LazyStrategy'", "examples": 0, "findings": 0, "source": "strategy = st.tuples(\n st.text(\n alphabet=string.whitespace,\n min_size=1,\n max_size=20\n ) +\n st.text(\n alphabet=string.digits + \".\",\n min_size=1,\n max_size=30\n ) +\n st.text(\n alphabet=string.whitespace,\n min_size=1,\n max_size=20\n ),\n st.just(\"\")\n)" }, { "id": "A5/s1", "attack": "A5", "valid": true, "error": null, "examples": 300, "findings": 0, "source": "strategy = st.lists(\n st.one_of(st.just(\".\"), st.integers(min_value=0, max_value=999)),\n min_size=1,\n max_size=5,\n).map(lambda parts: \".\".join(str(p) for p in parts)).filter(\n lambda s: s.count(\".\") >= 1 and s.rsplit(\".\", 1)[-1] == \"0\"\n)" }, { "id": "A5/s2", "attack": "A5", "valid": false, "error": "syntax error: invalid syntax (line 9)", "examples": 0, "findings": 0, "source": "strategy = st.lists(\n st.one_of(\n st.integers(min_value=0, max_value=999),\n st.text(st.characters(min_codepoint=48, max_codepoint=57)),\n ),\n min_size=1,\n max_size=4,\n).map(lambda parts: \".\".join(str(p) for p in parts))\n.strategy = strategy.example(\"3.2.0\").example(\"10.0\").example(\"0.0.0\")" }, { "id": "A5/s3", "attack": "A5", "valid": true, "error": null, "examples": 300, "findings": 0, "source": "strategy = st.lists(\n st.integers(min_value=0, max_value=999),\n min_size=1,\n max_size=5\n).map(lambda parts: \".\".join(str(p) for p in parts)).filter(\n lambda s: s.endswith(\".\") or any(s.rsplit(\".\", 1)[-1] == \"0\" for _ in [1])\n).map(st.just)" }, { "id": "A5/s4", "attack": "A5", "valid": true, "error": "TypeError: SearchStrategy.example() takes 1 positional argument but 2 were given", "examples": 0, "findings": 0, "source": "strategy = st.tuples(\n st.text(\n alphabet=st.characters(whitelist_categories=(\"Nd\",)),\n min_size=1,\n max_size=4,\n ).example(lambda x: x),\n st.integers(min_value=0, max_value=999),\n)" } ], "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": [ "A3/s3", "A4/s3", "mutation:whitespace-inner" ] }, { "signature": "P2|outcome|exc:packaging.version.InvalidVersion|ok|non-ascii+whitespace", "probe": "P2", "detail": "outcome", "args": [ [ " ١.2.3 " ] ], "base": { "status": "exc", "exc": "packaging.version.InvalidVersion" }, "head": { "status": "ok", "obs": { "str": "1.2.3", "repr": "", "attr:release": [ 1, 2, 3 ], "attr:public": "1.2.3" } }, "found_by": [ "mutation:unicode-digits" ] }, { "signature": "P2|outcome|exc:builtins.ValueError|exc:packaging.version.InvalidVersion|long-digits+whitespace", "probe": "P2", "detail": "outcome", "args": [ [ " 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.2.3 " ] ], "base": { "status": "exc", "exc": "builtins.ValueError" }, "head": { "status": "exc", "exc": "packaging.version.InvalidVersion" }, "found_by": [ "mutation:huge-number" ] }, { "signature": "P2|outcome|exc:builtins.ValueError|exc:packaging.version.InvalidVersion|long-digits", "probe": "P2", "detail": "outcome", "args": [ [ "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0" ] ], "base": { "status": "exc", "exc": "builtins.ValueError" }, "head": { "status": "exc", "exc": "packaging.version.InvalidVersion" }, "found_by": [ "mutation:huge-number" ] }, { "signature": "P2|outcome|exc:packaging.version.InvalidVersion|ok|non-ascii", "probe": "P2", "detail": "outcome", "args": [ [ "١.0.0" ] ], "base": { "status": "exc", "exc": "packaging.version.InvalidVersion" }, "head": { "status": "ok", "obs": { "str": "1.0.0", "repr": "", "attr:release": [ 1, 0, 0 ], "attr:public": "1.0.0" } }, "found_by": [ "mutation:unicode-digits" ] }, { "signature": "P2|outcome|exc:builtins.ValueError|exc:packaging.version.InvalidVersion|long-digits+non-ascii+whitespace", "probe": "P2", "detail": "outcome", "args": [ [ "　 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.2.3 　" ] ], "base": { "status": "exc", "exc": "builtins.ValueError" }, "head": { "status": "exc", "exc": "packaging.version.InvalidVersion" }, "found_by": [ "mutation:huge-number" ] } ], "usd_by_tier": { "reasoning": 0.046366, "volume": 0.0009975599999999998 }, "seconds": { "plan": 26.9, "generate": 7.49, "search": 13.38, "batch": 2.34, "total": 50.11 } }, "adjudication": { "target": "packaging.version:Version", "verdicts": [ { "signature": "P2|outcome|exc:packaging.version.InvalidVersion|ok|whitespace", "label": "likely-bug", "votes": { "likely-bug": 3 }, "rationale": "Fast‑path added in src/packaging/version.py strips only leading/trailing whitespace and then splits on '.'; internal spaces such as \"0. 0\" pass the fast path (since space is not in _NON_SIMPLE_VERSION_INDICATORS) and int(\" 0\") succeeds, whereas the original PEP‑440 regex rejected internal spaces, raising InvalidVersion. This change was not documented and appears unintentional.", "evidence": [ "_NON_SIMPLE_VERSION_INDICATORS = frozenset(\"!+-ABCDEHILOPRSTVW_abcdehiloprstvw\")", "if _NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version):", " self._release = tuple(map(int, version.strip().split(\".\")))", "+_NON_SIMPLE_VERSION_INDICATORS = frozenset(\"!+-ABCDEHILOPRSTVW_abcdehiloprstvw\")", "+ if _NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version):", "+ self._release = tuple(map(int, version.strip().split(\".\")))", "+ except ValueError:", "+ raise InvalidVersion(f\"Invalid version: {version!r}\") from None", "self._release = tuple(map(int, version.strip().split(\".\")))" ], "rejected": [ "+ try:" ], "reason": "" }, { "signature": "P2|outcome|exc:packaging.version.InvalidVersion|ok|non-ascii+whitespace", "label": "likely-bug", "votes": { "likely-bug": 3 }, "rationale": "The fast‑path treats any characters not in _NON_SIMPLE_VERSION_INDICATORS as “simple”. Arabic‑Indic digit “١” is not in that set, so the version \" ١.2.3 \" passes the fast path after stripping spaces, and int(\"١\") succeeds (Python accepts Unicode digits). The original PEP 440 regex only accepts ASCII digits, so it raised InvalidVersion. This 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(\".\")))", "+_NON_SIMPLE_VERSION_INDICATORS = frozenset(\"!+-ABCDEHILOPRSTVW_abcdehiloprstvw\")", "+ if _NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version):", "+ self._release = tuple(map(int, version.strip().split(\".\")))", "+ except ValueError:", "+ raise InvalidVersion(f\"Invalid version: {version!r}\") from None", "self._release = tuple(map(int, version.strip().split(\".\")))" ], "rejected": [ "+ try:" ], "reason": "" }, { "signature": "P2|outcome|exc:builtins.ValueError|exc:packaging.version.InvalidVersion|long-digits+whitespace", "label": "likely-bug", "votes": { "likely-bug": 2, "intended": 1 }, "rationale": "A very long version consisting only of digits and dots contains no indicator characters, so the fast path parses it into a huge tuple of ints and returns successfully. The original regex‑based validation rejected it with a ValueError (InvalidVersion). Accepting arbitrarily long releases bypasses PEP 440 validation and is an unintended performance shortcut.", "evidence": [ "_NON_SIMPLE_VERSION_INDICATORS = frozenset(\"!+-ABCDEHILOPRSTVW_abcdehiloprstvw\")", "if _NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version):", " self._release = tuple(map(int, version.strip().split(\".\")))", "except ValueError:", " raise InvalidVersion(f\"Invalid version: {version!r}\") from None" ], "rejected": [ "+ try:", "try:" ], "reason": "" }, { "signature": "P2|outcome|exc:builtins.ValueError|exc:packaging.version.InvalidVersion|long-digits", "label": "likely-bug", "votes": { "likely-bug": 2, "intended": 1 }, "rationale": "Same reasoning as C3 – an extremely long numeric version passes the fast path because it contains only digits and dots, while the original regex raised ValueError. The fast path unintentionally relaxes the version length limits.", "evidence": [ "_NON_SIMPLE_VERSION_INDICATORS = frozenset(\"!+-ABCDEHILOPRSTVW_abcdehiloprstvw\")", "if _NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version):", " self._release = tuple(map(int, version.strip().split(\".\")))", "except ValueError:", " raise InvalidVersion(f\"Invalid version: {version!r}\") from None" ], "rejected": [ "+ try:", "try:" ], "reason": "" }, { "signature": "P2|outcome|exc:packaging.version.InvalidVersion|ok|non-ascii", "label": "likely-bug", "votes": { "likely-bug": 3 }, "rationale": "Arabic‑Indic digit “١” is not in the indicator set, so the fast path accepts \"١.0.0\" after stripping and splitting, converting the Unicode digit with int(). The original regex only allowed ASCII digits, raising InvalidVersion. Accepting non‑ASCII digits is a regression.", "evidence": [ "_NON_SIMPLE_VERSION_INDICATORS = frozenset(\"!+-ABCDEHILOPRSTVW_abcdehiloprstvw\")", "if _NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version):", " self._release = tuple(map(int, version.strip().split(\".\")))", "+_NON_SIMPLE_VERSION_INDICATORS = frozenset(\"!+-ABCDEHILOPRSTVW_abcdehiloprstvw\")", "+ if _NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version):", "+ self._release = tuple(map(int, version.strip().split(\".\")))", "+ except ValueError:", "+ raise InvalidVersion(f\"Invalid version: {version!r}\") from None", "self._release = tuple(map(int, version.strip().split(\".\")))" ], "rejected": [ "+ try:" ], "reason": "" }, { "signature": "P2|outcome|exc:builtins.ValueError|exc:packaging.version.InvalidVersion|long-digits+non-ascii+whitespace", "label": "likely-bug", "votes": { "likely-bug": 2, "intended": 1 }, "rationale": "A version with a leading ideographic space and a massive numeric component contains no indicator characters; strip() removes the leading space and the fast path parses the huge numeric segments successfully. The original validator rejected it with ValueError. This is another unintended relaxation of validation.", "evidence": [ "_NON_SIMPLE_VERSION_INDICATORS = frozenset(\"!+-ABCDEHILOPRSTVW_abcdehiloprstvw\")", "if _NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version):", " self._release = tuple(map(int, version.strip().split(\".\")))", "except ValueError:", " raise InvalidVersion(f\"Invalid version: {version!r}\") from None" ], "rejected": [ "+ try:", "try:" ], "reason": "" } ], "samples": 3, "usd": 0.042443 }, "perf": { "run_id": "c1a7799be95f", "target": "packaging.version:Version", "image": "bw-pair:348e2d05c100a5f9", "backend": "docker", "families": [ { "id": "F1", "kind": "claimed_speedup", "family": "Added a fast‑path that detects “simple” numeric versions (only digits and dots) with a fast frozenset disjoint check and then parses them with a cheap split‑and", "why": "Added a fast‑path that detects “simple” numeric versions (only digits and dots) with a fast frozenset disjoint check and then parses them with a cheap split‑and‑int conversion, bypassing the full PEP 440 regex parser for the common case of plain numeric versions such as \"1.2.3\".", "size_meaning": "speedup", "make_source": "def make(n):\n result = []\n for _ in range(n % 8 + 1):\n args = []\n # seed‑based deterministic choices for version strings\n i = _ % 10\n if i == 0:\n v = \"1.2.3\"\n elif i == 1:\n v = \"0.0.1\"\n elif i == 2:\n v = \"10.20.30\"\n elif i == 3:\n v = \"1.0.0-alpha\"\n elif i == 4:\n v = \"2.3.4+build\"\n elif i == 5:\n v = \"1.2.3.dev1\"\n elif i == 6:\n v = \"1.2.3rc1\"\n elif i == 7:\n v = \"1.2.3.post1\"\n else:\n v = \"1.2.3\"\n args.append([v])\n result.append(args)\n return result", "example_args": [], "origin": "plan", "screen_ratio": 0.9863714559272647, "valid_fraction": 0.0, "error": null }, { "id": "F2", "kind": "suspected_slowdown", "family": "performance_optimization", "why": "Adds a fast-path for simple numeric versions (e.g., 1.2.3) to bypass full PEP 440 regex parsing.", "size_meaning": "xs", "make_source": "def make(n):\n return [[\"1.\" * n + \"2\"]]", "example_args": [ [ "1.2.3" ] ], "origin": "plan", "screen_ratio": 0.644451582146806, "valid_fraction": 1.0, "error": null }, { "id": "F3", "kind": "claimed_speedup", "family": "Fast‑path for simple numeric versions", "why": "Added a fast‑path guard (`_NON_SIMPLE_VERSION_INDICATORS.isdisjoint(version)`) that detects versions consisting only of digits and dots (e.g. \"1.2.3\") and parses them with a cheap `split('.')` + `map(int, …)` instead of running the full PEP 440 regex. This avoids the regex engine for the common case of plain numeric versions and therefore claims a speed‑up.", "size_meaning": "speedup", "make_source": "def make(n):\n # Generate 1–8 argument lists; each list contains 1–3 simple numeric version strings.\n # Cost grows with n because the loop and number of generated pairs increase.\n args = []\n for _ in range(1 + (n % 8)):\n versions = []\n for _ in range(1 + (n % 3)):\n # Build a plain numeric version string like \"1.2.3\" (no letters, no prerelease suffixes)\n parts = [str(1 + (n % 9)), str(1 + (n % 9)), str(1 + (n % 9))]\n versions.append(\".\".join(parts))\n args.append(versions)\n return args", "example_args": [], "origin": "plan", "screen_ratio": 0.9999545081533796, "valid_fraction": 0.0, "error": null }, { "id": "F4", "kind": "suspected_slowdown", "family": "The fast‑path guard uses a Python‑level frozenset `isdisjoint` check that iterates over every character of the version string until it finds a “non‑simple” indi", "why": "The fast‑path guard uses a Python‑level frozenset `isdisjoint` check that iterates over every character of the version string until it finds a “non‑simple” indicator. For typical PEP 440 versions containing letters (e.g. \"1.2.3a1\", \"2.0.0rc1\") this loop runs in Python bytecode, which is slower than the previous single C‑level regex match that would fail fast in compiled code.", "size_meaning": "slowdown", "make_source": "def make(n):\n count = itertools.count\n randint = random.randint\n ceil = math.ceil\n log2 = math.log2\n\n # Deterministic version strings that hit the slow Python isdisjoint path.\n # Each version contains letters (a/r/c/post) and dots/digits to vary length.\n templates = [\n \"1.2.3a1\",\n \"2.0.0rc1\",\n \"3.4.5.post1\",\n \"1.0.0.dev1\",\n \"0.9.0a12\",\n \"10.20.30rc2\",\n \"1.2.3.post4\",\n \"5.6.7a1\",\n ]\n\n # Choose a base template depending on n (more n -> longer/heavier strings)\n idx = min(n - 1, len(templates) - 1)\n base = templates[idx]\n\n # Stretch the version string so the character‑by‑character Python loop\n # takes noticeably longer without being absurdly huge.\n # We insert repeated digit blocks; length grows ~ O(log n).\n stretch = base + \".\" * (1 + (n // 5)) + \"\".join(str(randint(0, 9)) for _ in range(ceil(log2(n + 1))))\n\n # Build argument list: a single positional argument – the version string.\n return [[stretch]]", "example_args": [], "origin": "plan", "screen_ratio": 1.0900511594405804, "valid_fraction": 0.0, "error": null }, { "id": "F5", "kind": "suspected_slowdown", "family": "Accidental acceptance of whitespace in simple versions", "why": "The fast‑path strips the input (`version.strip()`) before splitting on `'.'`. `int()` tolerates leading/trailing whitespace, so strings like \" 1.2.3 \" or \"\\t2.0\\n\" are now accepted as valid versions even though PEP 440 forbids whitespace. The original regex would reject them, so this is a functional regression (accepting invalid input) rather than a performance regression.", "size_meaning": "regression", "make_source": "def make(n):\n # n >= 1 generates n distinct whitespace-ambiguous test strings.\n # Each input is a valid PEP 440 version once stripped, but contains\n # leading/trailing whitespace that the fast‑path would incorrectly accept.\n result = []\n for i in range(1, min(n, 8) + 1):\n # i dots => i+1 segments; we add whitespace around the whole string\n # and between some segments to probe the strip‑then‑split fast‑path.\n base = \".\".join(str(j) for j in range(1, i + 2))\n # Prepend/append a single space and intersperse a tab for variety.\n s = \" \" + base + \" \"\n if i > 1:\n # insert a tab between the first two segments\n s = s.replace(\".\", \"\\t.\", 1)\n result.append([s])\n return result", "example_args": [], "origin": "plan", "screen_ratio": 0.9247185740303128, "valid_fraction": 0.125, "error": null }, { "id": "F6", "kind": "suspected_slowdown", "family": "When the fast path is taken (pure numeric versions), the version string is stripped, split on ‘.’, and each component is converted with `int`. This allocates a ", "why": "When the fast path is taken (pure numeric versions), the version string is stripped, split on ‘.’, and each component is converted with `int`. This allocates a list of substrings and a tuple of ints in Python, whereas the old regex parser built the release tuple directly in C. For very short version strings the overhead of Python‑level splitting and mapping can outweigh the regex cost.", "size_meaning": "slowdown", "make_source": "def make(n):\n seeds = [13, 7, 21, 99, 3, 5, 17, 42]\n result = []\n for i in range(1, min(n, 8) + 1):\n seed = seeds[i - 1]\n rng = random.Random(seed)\n length = rng.randint(1, 5)\n parts = [str(rng.randint(0, 999)) for _ in range(length)]\n version_str = \".\".join(parts)\n args = [version_str]\n result.append(args)\n return result", "example_args": [], "origin": "plan", "screen_ratio": 0.4404265335596345, "valid_fraction": 1.0, "error": null }, { "id": "R1", "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": 2.0933183121944663, "valid_fraction": 0.0, "error": null }, { "id": "R2", "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": 2.0933183121944663, "valid_fraction": 0.0, "error": null }, { "id": "R3", "kind": "suspected_slowdown", "family": "Each numeric chunk consists of repeated digits (`'9'*i`) instead of zero-padded numbers", "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 chunks = []\n for i in range(1, n+1):\n chunks.append('9' * i)\n version = '.'.join(chunks) + 'c5'\n return [(version,)]", "example_args": [], "origin": "archive", "screen_ratio": 1.2879795827846565, "valid_fraction": 1.0, "error": "ladder inputs exceed 2000000 chars at n=4096; ladder stops here" }, { "id": "R4", "kind": "suspected_slowdown", "family": "Each numeric chunk increases digit count linearly while keeping total chunks fixed", "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 chunks = []\n for i in range(1, n+1):\n chunks.append(str(i).zfill(i))\n version = '.'.join(chunks) + 'c5'\n return [(version,)]", "example_args": [], "origin": "archive", "screen_ratio": 1.2735706618996405, "valid_fraction": 1.0, "error": "ladder inputs exceed 2000000 chars at n=4096; ladder stops here" }, { "id": "R3.1", "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": "expand:R3", "screen_ratio": 2.3848235530124784, "valid_fraction": 0.0, "error": "ladder inputs exceed 2000000 chars at n=4096; ladder stops here" }, { "id": "R3.2", "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": "expand:R3", "screen_ratio": 1.3151357893422584, "valid_fraction": 1.0, "error": "ladder inputs exceed 2000000 chars at n=4096; ladder stops here" }, { "id": "R3.3", "kind": "suspected_slowdown", "family": "Repeating triple-digit pattern in each chunk", "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 base_pattern = '456'\n for i in range(n):\n repeats = math.ceil((i + 1) / len(base_pattern))\n s = (base_pattern * repeats)[:i + 1]\n chunks.append(s)\n version = '.'.join(chunks) + '+build.1'\n return [(version,)]", "example_args": [], "origin": "expand:R3", "screen_ratio": 1.2324345567588313, "valid_fraction": 1.0, "error": "ladder inputs exceed 2000000 chars at n=4096; ladder stops here" }, { "id": "R4.1", "kind": "suspected_slowdown", "family": "Each segment contains repeated identical digits instead of unique numbers", "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 d = str((ord('0') + (9 * hash(\\\"REPEAT\\\") % 10)))\n parts = []\n for i in range(1, n+1):\n parts.append(d * i)\n ver = \".\".join(parts) + \"c5\"\n return [(ver,)]", "example_args": [], "origin": "expand:R4", "screen_ratio": null, "valid_fraction": null, "error": "make(n) rejected: syntax error: unexpected character after line continuation character (line 3)" }, { "id": "R4.2", "kind": "suspected_slowdown", "family": "Segments grow exponentially in digit size but share a common prefix", "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 = \\\"aaaaaaa\\\" # constant\n seg_len = lambda k: 2 ** min(k, 6) # exponential growth capped\n pieces = []\n for i in range(1, n+1):\n pad = '\\\\'0\\\\' * (seg_len(i))\n part = f\\\"{base}{pad}\\\"\n pieces.append(part)\n v = \\\".\\\".join(pieces) + \\\"rc1\\\"\n return [(v,)]", "example_args": [], "origin": "expand:R4", "screen_ratio": null, "valid_fraction": null, "error": "make(n) rejected: syntax error: unexpected character after line continuation character (line 3)" }, { "id": "R4.3", "kind": "suspected_slowdown", "family": "Chunks stay small but are separated by variable-length non-digit markers", "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 inner = [''] * (n-1)\n for idx in range(n-1):\n filler = '#'\n inner[idx] = filler * ((idx+1)%4 + 1)\n nums = [str(j%10) for j in range(n)]\n comps = []\n for j in range(len(nums)):\n comps.append(nums[j])\n if j < len(inner):\n comps.append(inner[j])\n body = ''.join(comps)\n full = body[::-1].lower() + '+local.build.with.many.dots'\n return [(full,)]}]}", "example_args": [], "origin": "expand:R4", "screen_ratio": null, "valid_fraction": null, "error": "make(n) rejected: syntax error: unmatched '}' (line 15)" } ], "findings": [ { "family_id": "R3.2", "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": "expand:R3", "screen_ratio": 1.3151357893422584, "valid_fraction": 1.0, "ladder": [ { "n": 2, "base_ir": 27447.955, "head_ir": 28619.16, "input_chars": 16.0, "ratio": 1.0426700276942307, "valid_fraction": 1.0, "judged": true }, { "n": 4, "base_ir": 31097.67, "head_ir": 33246.855, "input_chars": 25.0, "ratio": 1.0691108047644728, "valid_fraction": 1.0, "judged": true }, { "n": 16, "base_ir": 57455.305785123965, "head_ir": 75561.52892561983, "input_chars": 163.0, "ratio": 1.3151357893422584, "valid_fraction": 1.0, "judged": true }, { "n": 64, "base_ir": 248078.77777777778, "head_ir": 478481.77777777775, "input_chars": 2155.0, "ratio": 1.9287493354485514, "valid_fraction": 1.0, "judged": true }, { "n": 256, "base_ir": 2470403.0, "head_ir": 6019570.0, "input_chars": 33163.0, "ratio": 2.4366753116799162, "valid_fraction": 1.0, "judged": true }, { "n": 1024, "base_ir": 45665559.0, "head_ir": 101941782.0, "input_chars": 525835.0, "ratio": 2.2323559424729695, "valid_fraction": 1.0, "judged": true } ], "slope_base": 0.6965041702512191, "slope_head": 0.7817671609001466, "top_inputs": [], "error": "ladder inputs exceed 2000000 chars at n=4096; ladder stops here", "verdict": "slower", "worst_ratio": 2.4366753116799162, "worst_search": null }, { "family_id": "R3", "kind": "suspected_slowdown", "family": "Each numeric chunk consists of repeated digits (`'9'*i`) instead of zero-padded numbers", "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.2879795827846565, "valid_fraction": 1.0, "ladder": [ { "n": 2, "base_ir": 27936.985, "head_ir": 29086.02, "input_chars": 10.0, "ratio": 1.0411295277568429, "valid_fraction": 1.0, "judged": true }, { "n": 4, "base_ir": 31591.67, "head_ir": 33728.855, "input_chars": 19.0, "ratio": 1.0676502698337886, "valid_fraction": 1.0, "judged": true }, { "n": 16, "base_ir": 58996.488, "head_ir": 75986.272, "input_chars": 157.0, "ratio": 1.2879795827846565, "valid_fraction": 1.0, "judged": true }, { "n": 64, "base_ir": 248572.66666666666, "head_ir": 478975.6666666667, "input_chars": 2149.0, "ratio": 1.9269040039264174, "valid_fraction": 1.0, "judged": true }, { "n": 256, "base_ir": 2470897.0, "head_ir": 6020064.0, "input_chars": 33157.0, "ratio": 2.4363880809276957, "valid_fraction": 1.0, "judged": true }, { "n": 1024, "base_ir": 45669797.0, "head_ir": 101942588.0, "input_chars": 525829.0, "ratio": 2.2321664359489053, "valid_fraction": 1.0, "judged": true } ], "slope_base": 0.6661289775416621, "slope_head": 0.7492839920008143, "top_inputs": [], "error": "ladder inputs exceed 2000000 chars at n=4096; ladder stops here", "verdict": "slower", "worst_ratio": 2.4363880809276957, "worst_search": null }, { "family_id": "R4", "kind": "suspected_slowdown", "family": "Each numeric chunk increases digit count linearly while keeping total chunks fixed", "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.2735706618996405, "valid_fraction": 1.0, "ladder": [ { "n": 2, "base_ir": 27941.985, "head_ir": 29085.02, "input_chars": 10.0, "ratio": 1.040907437320577, "valid_fraction": 1.0, "judged": true }, { "n": 4, "base_ir": 31576.09, "head_ir": 33673.275, "input_chars": 19.0, "ratio": 1.0664168679529353, "valid_fraction": 1.0, "judged": true }, { "n": 16, "base_ir": 58978.488, "head_ir": 75113.272, "input_chars": 157.0, "ratio": 1.2735706618996405, "valid_fraction": 1.0, "judged": true }, { "n": 64, "base_ir": 244281.66666666666, "head_ir": 460916.6666666667, "input_chars": 2149.0, "ratio": 1.88682463549591, "valid_fraction": 1.0, "judged": true }, { "n": 256, "base_ir": 2211036.0, "head_ir": 5533576.0, "input_chars": 33157.0, "ratio": 2.5027073281484338, "valid_fraction": 1.0, "judged": true }, { "n": 1024, "base_ir": 29877973.0, "head_ir": 82493597.0, "input_chars": 525829.0, "ratio": 2.7610171881472683, "valid_fraction": 1.0, "judged": true } ], "slope_base": 0.6331464790264557, "slope_head": 0.7318001954642295, "top_inputs": [ { "args": [ "1.02.003.0004.00005.000006.0000007.00000008.000000009.0000000010.00000000011.000000000012.0000000000013.00000000000014.000000000000015.0000000000000016.00000000000000017.000000000000000018.0000000000000000019.00000000000000000020.000000000000000000021.0000000000000000000022c5" ], "cpu_ratio": 4.441, "base_ir": 74197.15714285715, "head_ir": 102775.15714285715, "ir_ratio": 1.3851630048975692, "outcome": "ok" }, { "args": [ "1.02.003.0004.00005.000006.0000007.00000008.000000009.0000000010.00000000011.000000000012.0000000000013.00000000000014.000000000000015.0000000000000016.00000000000000017.000000000000000018.0000000000000000019.00000000000000000020.000000000000000000021.0000000000000000000022.00000000000000000000023.000000000000000000000024.0000000000000000000000025.00000000000000000000000026.000000000000000000000000027.0000000000000000000000000028c5" ], "cpu_ratio": 3.56, "base_ir": 92992.91111111111, "head_ir": 137638.9111111111, "ir_ratio": 1.4801011116498486, "outcome": "ok" } ], "error": "ladder inputs exceed 2000000 chars at n=4096; ladder stops here", "verdict": "slower", "worst_ratio": 2.7610171881472683, "worst_search": { "args": [ "1.02.003.0004.00005.000006.0000007.00000008.000000009.0000000010.00000000011.000000000012.0000000000013.00000000000014.000000000000015.0000000000000016.00000000000000017.000000000000000018.0000000000000000019.00000000000000000020.000000000000000000021.0000000000000000000022.00000000000000000000023.000000000000000000000024.0000000000000000000000025.00000000000000000000000026.000000000000000000000000027.0000000000000000000000000028c5" ], "cpu_ratio": 3.56, "base_ir": 92992.91111111111, "head_ir": 137638.9111111111, "ir_ratio": 1.4801011116498486, "outcome": "ok" } }, { "family_id": "R3.3", "kind": "suspected_slowdown", "family": "Repeating triple-digit pattern in each chunk", "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:R3", "screen_ratio": 1.2324345567588313, "valid_fraction": 1.0, "ladder": [ { "n": 2, "base_ir": 35529.89, "head_ir": 36692.505, "input_chars": 16.0, "ratio": 1.0327221671668558, "valid_fraction": 1.0, "judged": true }, { "n": 4, "base_ir": 39188.055, "head_ir": 41309.71, "input_chars": 25.0, "ratio": 1.0541403496550161, "valid_fraction": 1.0, "judged": true }, { "n": 16, "base_ir": 67146.06611570247, "head_ir": 82753.13223140496, "input_chars": 163.0, "ratio": 1.2324345567588313, "valid_fraction": 1.0, "judged": true }, { "n": 64, "base_ir": 256815.44444444444, "head_ir": 483002.44444444444, "input_chars": 2155.0, "ratio": 1.880737529198443, "valid_fraction": 1.0, "judged": true }, { "n": 256, "base_ir": 2479191.0, "head_ir": 5962515.0, "input_chars": 33163.0, "ratio": 2.4050244616086456, "valid_fraction": 1.0, "judged": true }, { "n": 1024, "base_ir": 45677341.0, "head_ir": 100900580.0, "input_chars": 525835.0, "ratio": 2.2089854135773797, "valid_fraction": 1.0, "judged": true } ], "slope_base": 0.6701623483984215, "slope_head": 0.7565762784420008, "top_inputs": [], "error": "ladder inputs exceed 2000000 chars at n=4096; ladder stops here", "verdict": "slower", "worst_ratio": 2.4050244616086456, "worst_search": null } ], "seconds": { "plan": 15.3, "screen": 94.61, "full": 153.61, "total": 263.52 }, "ladder_validity": "backfilled 2026-10-11 (scripts/backtest/backfill_ladder_validity.py)" }, "usd_by_tier": { "reasoning": 0.109316, "volume": 0.0015901799999999994, "proposer": 0.0009339000000000001 }, "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:packaging.version.InvalidVersion|ok|non-ascii+whitespace", "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 InvalidVersion, Version\n with pytest.raises(InvalidVersion) as excinfo:\n Version(' ١.2.3 ')\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.ValueError|exc:packaging.version.InvalidVersion|long-digits+whitespace", "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 Version\n with pytest.raises(ValueError) as excinfo:\n Version(' 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.2.3 ')\n assert type(excinfo.value) is ValueError # exact type: a subclass would be a behaviour change\n", "base": "pass", "head": "fail", "skipped": "", "verified": true }, { "signature": "P2|outcome|exc:builtins.ValueError|exc:packaging.version.InvalidVersion|long-digits", "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 Version\n with pytest.raises(ValueError) as excinfo:\n Version('1' + '0' * 4300 + '.' + '0')\n assert type(excinfo.value) is ValueError # 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", "name": "test_p2_outcome_4", "source": "def test_p2_outcome_4():\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.ValueError|exc:packaging.version.InvalidVersion|long-digits+non-ascii+whitespace", "name": "test_p2_outcome_5", "source": "def test_p2_outcome_5():\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(ValueError) as excinfo:\n Version('\\u3000 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.2.3 \\u3000')\n assert type(excinfo.value) is ValueError # exact type: a subclass would be a behaviour change\n", "base": "pass", "head": "fail", "skipped": "", "verified": true } ], "regression_tests_note": "generated and verified after the run (2026-10-09), from the recorded findings and labels; no model calls" }