⚡️ Speed up function parse_req_python_version by 78%

[codeflash-ai]

📄 78% (0.78x) speedup for parse_req_python_version in src/black/files.py

⏱️ Runtime : 19.5 milliseconds → 10.9 milliseconds (best of 116 runs)

📝 Explanation and details

The optimization adds a fast-path string parsing for common Python version strings before falling back to the expensive Version object construction.

Key Changes:

• Early string-based parsing: For version strings starting with "3.", the code directly splits on dots and parses the minor version as an integer, avoiding the costly Version() constructor
• Selective optimization: Only handles the most common case (3.x format), falling back to original logic for complex version strings (pre-releases, epochs, etc.)

Why It's Faster:
The profiler shows Version(requires_python) consumed 78% of runtime (51.9ms out of 66.6ms total). The optimization bypasses this for simple cases:

• String operations (startswith, split, isdigit) are much faster than full version parsing
• TargetVersion(int(parts[1])) is significantly cheaper than accessing version.release[1] after full parsing

Performance Characteristics:

• Excellent for simple versions (3.7, 3.8, 3.10): 300-600% speedup as shown in tests
• Slight overhead for complex versions (pre-releases, epochs): 2-30% slower due to double processing, but these are rare in practice
• Large-scale operations: 200-500% faster for batch processing of standard version strings

The optimization targets the dominant use case while preserving all edge case handling, making it highly effective for typical Python version parsing workloads.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 4970 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

from typing import Optional # imports import pytest # used for our unit tests from black.files import parse_req_python_version # function to test from black.mode import TargetVersion from packaging.version import InvalidVersion, Version # unit tests # ------------------- Basic Test Cases ------------------- def test_basic_valid_python_versions(): # Basic valid Python 3 versions codeflash_output = parse_req_python_version("3.7") # 18.0μs -> 3.08μs (484% faster) codeflash_output = parse_req_python_version("3.8") # 7.58μs -> 1.18μs (542% faster) codeflash_output = parse_req_python_version("3.9") # 5.46μs -> 860ns (535% faster) codeflash_output = parse_req_python_version("3.10") # 5.29μs -> 1.17μs (351% faster) codeflash_output = parse_req_python_version("3.11") # 4.60μs -> 775ns (493% faster) def test_basic_version_with_patch(): # Patch version should still map to minor version codeflash_output = parse_req_python_version("3.7.3") # 13.3μs -> 2.48μs (436% faster) codeflash_output = parse_req_python_version("3.8.0") # 7.35μs -> 1.05μs (597% faster) def test_basic_version_with_leading_zeros(): # Leading zeros in minor version codeflash_output = parse_req_python_version("3.07") # 12.6μs -> 2.53μs (399% faster) codeflash_output = parse_req_python_version("3.010") # 6.84μs -> 1.23μs (458% faster) # ------------------- Edge Test Cases ------------------- def test_non_python3_versions(): # Should return None for non-Python3 major versions codeflash_output = parse_req_python_version("2.7") # 11.1μs -> 16.0μs (30.7% slower) codeflash_output = parse_req_python_version("1.0") # 6.29μs -> 6.91μs (9.08% slower) codeflash_output = parse_req_python_version("4.0") # 4.63μs -> 4.78μs (3.20% slower) def test_missing_minor_version(): # Should raise IndexError and return None if no minor version codeflash_output = parse_req_python_version("3") # 11.2μs -> 12.0μs (6.59% slower) def test_invalid_version_strings(): # Should raise InvalidVersion for malformed version strings with pytest.raises(InvalidVersion): parse_req_python_version("three.seven") # 3.22μs -> 3.54μs (9.03% slower) with pytest.raises(InvalidVersion): parse_req_python_version("3.x") # 4.06μs -> 4.66μs (12.9% slower) with pytest.raises(InvalidVersion): parse_req_python_version("") # 930ns -> 1.05μs (11.2% slower) def test_large_minor_version(): # Should work for large minor versions codeflash_output = parse_req_python_version("3.99") # 21.6μs -> 6.53μs (231% faster) def test_extra_long_version_string(): # Should ignore extra patch numbers, only minor is mapped codeflash_output = parse_req_python_version("3.7.5.6.7") # 15.2μs -> 2.79μs (445% faster) def test_version_with_pre_release_and_post_release(): # Should still parse minor correctly codeflash_output = parse_req_python_version("3.8a1") # 15.6μs -> 20.4μs (23.3% slower) codeflash_output = parse_req_python_version("3.9b2") # 8.51μs -> 9.19μs (7.39% slower) codeflash_output = parse_req_python_version("3.10rc1") # 6.75μs -> 7.57μs (10.7% slower) codeflash_output = parse_req_python_version("3.11.post3") # 7.70μs -> 1.39μs (454% faster) def test_version_with_epoch(): # Should handle epoch correctly codeflash_output = parse_req_python_version("1!3.7") # 13.0μs -> 13.3μs (2.49% slower) def test_version_with_local_and_dev(): # Should still parse minor correctly codeflash_output = parse_req_python_version("3.8.dev0") # 14.6μs -> 2.54μs (476% faster) codeflash_output = parse_req_python_version("3.9+abc") # 11.6μs -> 16.4μs (29.2% slower) # ------------------- Large Scale Test Cases ------------------- def test_many_valid_versions(): # Test a large number of valid minor versions for minor in range(0, 100): version_str = f"3.{minor}" codeflash_output = parse_req_python_version(version_str) # 526μs -> 152μs (246% faster) def test_many_invalid_versions(): # Test a large number of invalid major versions for major in range(0, 10): if major == 3: continue version_str = f"{major}.7" codeflash_output = parse_req_python_version(version_str) # 44.1μs -> 48.3μs (8.71% slower) def test_large_patch_numbers(): # Test with large patch numbers for patch in range(0, 100): version_str = f"3.7.{patch}" codeflash_output = parse_req_python_version(version_str) # 464μs -> 79.2μs (487% faster) def test_large_scale_malformed_versions(): # Test many malformed version strings for i in range(100): with pytest.raises(InvalidVersion): parse_req_python_version(f"3.x{i}") def test_large_scale_missing_minor_versions(): # Test many major-only versions for i in range(3, 10): codeflash_output = parse_req_python_version(str(i)) # 40.7μs -> 40.9μs (0.426% slower) def test_large_scale_pre_release_versions(): # Test many pre-release versions for minor in range(0, 100): codeflash_output = parse_req_python_version(f"3.{minor}a1") # 557μs -> 569μs (2.01% slower) codeflash_output = parse_req_python_version(f"3.{minor}b2") codeflash_output = parse_req_python_version(f"3.{minor}rc1") # 547μs -> 556μs (1.60% slower) def test_large_scale_local_and_dev_versions(): # Test many local and dev release versions for minor in range(0, 100): codeflash_output = parse_req_python_version(f"3.{minor}.dev{minor}") # 592μs -> 160μs (269% faster) codeflash_output = parse_req_python_version(f"3.{minor}+local") # codeflash_output is used to check that the output of the original code is the same as that of the optimized code. #------------------------------------------------ from typing import Optional # imports import pytest # used for our unit tests from black.files import parse_req_python_version # function to test from black.mode import TargetVersion from packaging.version import Version # unit tests # 1. Basic Test Cases def test_basic_valid_python_version(): # Test with a valid Python 3.7 version string codeflash_output = parse_req_python_version("3.7") # 17.5μs -> 3.18μs (451% faster) # Test with a valid Python 3.8 version string codeflash_output = parse_req_python_version("3.8") # 7.20μs -> 1.11μs (547% faster) # Test with a valid Python 3.9 version string codeflash_output = parse_req_python_version("3.9") # 5.46μs -> 822ns (564% faster) # Test with a valid Python 3.10 version string codeflash_output = parse_req_python_version("3.10") # 5.21μs -> 1.19μs (338% faster) # Test with a valid Python 3.11 version string codeflash_output = parse_req_python_version("3.11") # 4.49μs -> 809ns (456% faster) def test_basic_valid_python_version_with_patch(): # Test with a valid Python 3.7.3 version string (patch should be ignored) codeflash_output = parse_req_python_version("3.7.3") # 13.3μs -> 2.57μs (417% faster) # Test with a valid Python 3.8.0 version string codeflash_output = parse_req_python_version("3.8.0") # 7.49μs -> 1.15μs (551% faster) def test_basic_valid_python_version_with_leading_zeros(): # Test with a valid Python 3.07 version string (should be interpreted as 7) codeflash_output = parse_req_python_version("3.07") # 12.3μs -> 2.55μs (383% faster) # Test with a valid Python 3.010 version string (should be interpreted as 10) codeflash_output = parse_req_python_version("3.010") # 6.99μs -> 1.25μs (458% faster) # 2. Edge Test Cases def test_invalid_major_version_returns_none(): # Test with Python 2.x version string codeflash_output = parse_req_python_version("2.7") # 10.5μs -> 16.0μs (34.0% slower) # Test with Python 4.x version string codeflash_output = parse_req_python_version("4.0") # 6.33μs -> 7.19μs (12.0% slower) # Test with Python 0.x version string codeflash_output = parse_req_python_version("0.1") # 4.88μs -> 5.05μs (3.29% slower) def test_invalid_minor_version_returns_none(): # Test with major version but no minor version (should raise IndexError and return None) codeflash_output = parse_req_python_version("3") # 11.0μs -> 11.7μs (5.94% slower) def test_invalid_version_string_raises(): # Test with completely invalid version string with pytest.raises(Exception) as excinfo: parse_req_python_version("not.a.version") # 3.25μs -> 3.52μs (7.51% slower) # Test with empty string with pytest.raises(Exception) as excinfo: parse_req_python_version("") # 1.28μs -> 1.46μs (12.1% slower) # Test with whitespace string with pytest.raises(Exception) as excinfo: parse_req_python_version(" ") # 2.29μs -> 2.41μs (5.10% slower) def test_version_with_prerelease_and_postrelease(): # Test with pre-release version string (should still parse the minor version) codeflash_output = parse_req_python_version("3.8a1") # 15.7μs -> 16.7μs (6.40% slower) codeflash_output = parse_req_python_version("3.9b2") # 8.34μs -> 9.03μs (7.66% slower) # Test with post-release version string codeflash_output = parse_req_python_version("3.10.post1") # 8.50μs -> 1.62μs (424% faster) # Test with dev-release version string codeflash_output = parse_req_python_version("3.11.dev0") # 7.24μs -> 929ns (679% faster) def test_version_with_epoch(): # Test with epoch in version string codeflash_output = parse_req_python_version("1!3.7") # 12.6μs -> 13.1μs (3.21% slower) # Test with epoch and patch codeflash_output = parse_req_python_version("2!3.8.1") # 7.80μs -> 7.94μs (1.76% slower) def test_version_with_local_version(): # Test with local version identifier codeflash_output = parse_req_python_version("3.7+local") # 16.0μs -> 16.7μs (3.95% slower) codeflash_output = parse_req_python_version("3.8.1+abc123") # 9.46μs -> 1.75μs (442% faster) def test_version_with_leading_and_trailing_spaces(): # Test with leading and trailing spaces codeflash_output = parse_req_python_version(" 3.7 ") # 11.6μs -> 11.9μs (2.57% slower) def test_version_with_large_minor_number(): # Test with a large minor version number codeflash_output = parse_req_python_version("3.999") # 14.9μs -> 5.64μs (165% faster) def test_version_with_negative_minor_number_returns_none(): # Negative minor version is not valid, but packaging.version.Version will parse it as 3.0 # So "3.-1" is invalid and should raise with pytest.raises(Exception) as excinfo: parse_req_python_version("3.-1") # 5.26μs -> 6.19μs (15.0% slower) def test_version_with_extraneous_characters_raises(): # Test with extraneous characters with pytest.raises(Exception) as excinfo: parse_req_python_version("3.7rc1#foo") # 7.95μs -> 8.61μs (7.66% slower) def test_version_with_only_patch_returns_none(): # Test with only patch version codeflash_output = parse_req_python_version("3.7.3") # 13.9μs -> 2.60μs (437% faster) codeflash_output = parse_req_python_version("3.7.0") # 7.67μs -> 1.23μs (526% faster) # 3. Large Scale Test Cases def test_large_scale_valid_versions(): # Test with a large number of valid version strings for minor in range(0, 1000): version_str = f"3.{minor}" codeflash_output = parse_req_python_version(version_str) # 5.16ms -> 1.52ms (239% faster) def test_large_scale_invalid_major_versions(): # Test with a large number of invalid major version strings for major in range(0, 1000): if major == 3: continue # skip valid major version version_str = f"{major}.7" codeflash_output = parse_req_python_version(version_str) # 3.81ms -> 3.85ms (1.03% slower) def test_large_scale_patch_versions(): # Test with a large number of patch versions for a valid minor for patch in range(0, 1000): version_str = f"3.7.{patch}" codeflash_output = parse_req_python_version(version_str) # 4.50ms -> 763μs (489% faster) def test_large_scale_prerelease_versions(): # Test with a large number of prerelease versions for a valid minor for minor in range(0, 100): version_str = f"3.{minor}a1" codeflash_output = parse_req_python_version(version_str) # 566μs -> 585μs (3.14% slower) def test_large_scale_invalid_strings(): # Test with a large number of invalid strings for i in range(0, 1000): with pytest.raises(Exception) as excinfo: parse_req_python_version(f"invalid.version.{i}") # codeflash_output is used to check that the output of the original code is the same as that of the optimized code. #------------------------------------------------ from black.files import parse_req_python_version import pytest def test_parse_req_python_version(): with pytest.raises(InvalidVersion, match="Invalid\\ version:\\ ''"): parse_req_python_version('')

To edit these changes git checkout codeflash/optimize-parse_req_python_version-mgsu0cal and push.