⚡️ Speed up function named by 30%

[codeflash-ai]

📄 30% (0.30x) speedup for named in xarray/coding/cftimeindex.py

⏱️ Runtime : 271 microseconds → 209 microseconds (best of 23 runs)

📝 Explanation and details

The optimization replaces string concatenation with f-string formatting in the named function. The original code uses "(?P<" + name + ">" + pattern + ")" which requires multiple string concatenation operations, while the optimized version uses f"(?P<{name}>{pattern})" which is a single f-string evaluation.

Key Performance Improvements:

• Reduced string operations: F-strings are compiled to more efficient bytecode that avoids intermediate string objects created during concatenation
• Better memory efficiency: String concatenation creates temporary string objects for each + operation, while f-strings build the result directly
• Optimized interpreter handling: Python's f-string implementation is specifically optimized at the C level

Impact Analysis:
The function is used in build_pattern() for parsing datetime strings in xarray's cftime handling, where it's called 6 times per pattern construction. Given that datetime parsing can occur frequently in data processing workflows, this 29% speedup provides meaningful performance benefits.

Test Results Show Consistent Gains:

• Simple cases: 20-40% faster (most common usage)
• Large strings: Up to 73% faster for very long inputs
• Repeated calls: 30% faster when called 1000 times
• All edge cases maintain correctness while gaining performance

The optimization is particularly effective for longer strings and repeated usage patterns, making it well-suited for xarray's datetime parsing operations where the function may be called many times during data processing.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from xarray.coding.cftimeindex import named

# unit tests

# ---------------------------
# Basic Test Cases
# ---------------------------


def test_named_basic_alphanumeric():
    # Basic test with simple alphanumeric name and pattern
    codeflash_output = named("foo", "bar")
    result = codeflash_output  # 943ns -> 659ns (43.1% faster)


def test_named_basic_with_digit_in_name():
    # Name contains digits
    codeflash_output = named("group1", "abc123")
    result = codeflash_output  # 930ns -> 723ns (28.6% faster)


def test_named_basic_with_special_pattern():
    # Pattern contains regex special characters
    codeflash_output = named("word", "\\w+")
    result = codeflash_output  # 796ns -> 653ns (21.9% faster)


def test_named_basic_with_empty_pattern():
    # Empty pattern string
    codeflash_output = named("empty", "")
    result = codeflash_output  # 865ns -> 635ns (36.2% faster)


# ---------------------------
# Edge Test Cases
# ---------------------------


def test_named_empty_name():
    # Empty name string
    codeflash_output = named("", "abc")
    result = codeflash_output  # 891ns -> 709ns (25.7% faster)


def test_named_name_with_special_characters():
    # Name contains special characters (not valid for regex group names, but function should not validate)
    codeflash_output = named("foo-bar", "baz")
    result = codeflash_output  # 846ns -> 692ns (22.3% faster)


def test_named_pattern_with_parentheses():
    # Pattern contains parentheses
    codeflash_output = named("paren", "(abc)")
    result = codeflash_output  # 894ns -> 710ns (25.9% faster)


def test_named_name_with_spaces():
    # Name contains spaces
    codeflash_output = named("my group", "abc")
    result = codeflash_output  # 927ns -> 610ns (52.0% faster)


def test_named_pattern_with_quotes():
    # Pattern contains quotes
    codeflash_output = named("quote", '"abc"')
    result = codeflash_output  # 870ns -> 693ns (25.5% faster)


def test_named_name_and_pattern_empty():
    # Both name and pattern are empty
    codeflash_output = named("", "")
    result = codeflash_output  # 883ns -> 633ns (39.5% faster)


def test_named_pattern_with_brackets_and_escapes():
    # Pattern contains brackets and escape sequences
    codeflash_output = named("bracket", "[a-z]\\d+")
    result = codeflash_output  # 896ns -> 716ns (25.1% faster)


def test_named_name_with_unicode_characters():
    # Name contains unicode characters
    codeflash_output = named("grüp", "abc")
    result = codeflash_output  # 1.04μs -> 883ns (17.3% faster)


def test_named_pattern_with_unicode_characters():
    # Pattern contains unicode characters
    codeflash_output = named("group", "äöüß")
    result = codeflash_output  # 1.14μs -> 869ns (31.1% faster)


def test_named_name_with_long_string():
    # Very long name string
    long_name = "a" * 100
    codeflash_output = named(long_name, "foo")
    result = codeflash_output  # 803ns -> 757ns (6.08% faster)


def test_named_pattern_with_long_string():
    # Very long pattern string
    long_pattern = "b" * 100
    codeflash_output = named("group", long_pattern)
    result = codeflash_output  # 974ns -> 687ns (41.8% faster)


# ---------------------------
# Large Scale Test Cases
# ---------------------------


def test_named_large_scale_many_calls():
    # Test calling named many times with different inputs
    for i in range(1000):
        name = f"group{i}"
        pattern = f"pat{i}"
        expected = f"(?P<{name}>{pattern})"
        codeflash_output = named(name, pattern)
        result = codeflash_output  # 209μs -> 160μs (30.5% faster)


def test_named_large_scale_long_inputs():
    # Test with very long name and pattern (up to 1000 chars)
    long_name = "n" * 1000
    long_pattern = "p" * 1000
    expected = f"(?P<{long_name}>{long_pattern})"
    codeflash_output = named(long_name, long_pattern)
    result = codeflash_output  # 1.47μs -> 846ns (73.2% faster)


def test_named_large_scale_pattern_with_various_characters():
    # Pattern contains a mix of many special characters
    special_chars = "".join(chr(i) for i in range(32, 127))
    codeflash_output = named("special", special_chars)
    result = codeflash_output  # 869ns -> 705ns (23.3% faster)
    expected = f"(?P<special>{special_chars})"


def test_named_large_scale_name_with_various_characters():
    # Name contains a mix of many special characters (not valid for regex, but function should not validate)
    special_chars = "".join(chr(i) for i in range(32, 127))
    codeflash_output = named(special_chars, "abc")
    result = codeflash_output  # 815ns -> 689ns (18.3% faster)
    expected = f"(?P<{special_chars}>abc)"


# ---------------------------
# Additional Edge Cases
# ---------------------------


def test_named_name_with_newline():
    # Name contains a newline character
    codeflash_output = named("line\nbreak", "abc")
    result = codeflash_output  # 788ns -> 685ns (15.0% faster)


def test_named_pattern_with_newline():
    # Pattern contains a newline character
    codeflash_output = named("group", "abc\ndef")
    result = codeflash_output  # 891ns -> 721ns (23.6% faster)


def test_named_name_with_tab():
    # Name contains a tab character
    codeflash_output = named("tab\tname", "abc")
    result = codeflash_output  # 850ns -> 618ns (37.5% faster)


def test_named_pattern_with_tab():
    # Pattern contains a tab character
    codeflash_output = named("group", "abc\tdef")
    result = codeflash_output  # 869ns -> 734ns (18.4% faster)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import re  # used for regex matching in test validation

# imports
import pytest  # used for our unit tests
from xarray.coding.cftimeindex import named

# unit tests

# ------------------------------
# Basic Test Cases
# ------------------------------


def test_named_basic_alpha():
    # Test with simple alpha pattern
    codeflash_output = named("foo", r"\w+")
    regex = codeflash_output  # 954ns -> 726ns (31.4% faster)
    # Test that the group is named correctly and matches expected string
    match = re.match(regex, "hello")


def test_named_basic_digits():
    # Test with digit pattern
    codeflash_output = named("digits", r"\d+")
    regex = codeflash_output  # 863ns -> 737ns (17.1% faster)
    match = re.match(regex, "12345")


def test_named_basic_literal():
    # Test with a literal pattern
    codeflash_output = named("literal", r"abc")
    regex = codeflash_output  # 842ns -> 680ns (23.8% faster)
    match = re.match(regex, "abc")


# ------------------------------
# Edge Test Cases
# ------------------------------


def test_named_empty_name():
    # Test with empty name (should still produce a valid regex, but group name is empty)
    codeflash_output = named("", r"\d+")
    regex = codeflash_output  # 897ns -> 635ns (41.3% faster)
    # This is an invalid regex, so re.compile should raise an error
    with pytest.raises(re.error):
        re.compile(regex)


def test_named_empty_pattern():
    # Test with empty pattern
    codeflash_output = named("foo", "")
    regex = codeflash_output  # 727ns -> 723ns (0.553% faster)
    # Should match empty string and group should be ''
    match = re.match(regex, "")


def test_named_special_characters_in_name():
    # Test with special characters in the group name (invalid in regex group names)
    codeflash_output = named("foo-bar", r"\d+")
    regex = codeflash_output  # 815ns -> 663ns (22.9% faster)
    # This is an invalid regex, so re.compile should raise an error
    with pytest.raises(re.error):
        re.compile(regex)


def test_named_special_characters_in_pattern():
    # Test with special regex characters in the pattern
    codeflash_output = named("foo", r"[a-z]{3,5}\d*")
    regex = codeflash_output  # 789ns -> 671ns (17.6% faster)
    match = re.match(regex, "abc123")


def test_named_unicode_name():
    # Test with unicode group name (allowed in Python 3.6+)
    codeflash_output = named("имя", r"\w+")
    regex = codeflash_output  # 1.13μs -> 1.06μs (6.50% faster)
    match = re.match(regex, "тест")


def test_named_group_name_starts_with_digit():
    # Group names can't start with a digit according to regex rules
    codeflash_output = named("1foo", r"\w+")
    regex = codeflash_output  # 822ns -> 713ns (15.3% faster)
    with pytest.raises(re.error):
        re.compile(regex)


def test_named_pattern_with_parentheses():
    # Test with pattern containing parentheses
    codeflash_output = named("foo", r"(abc|def)")
    regex = codeflash_output  # 892ns -> 735ns (21.4% faster)
    match = re.match(regex, "abc")
    match = re.match(regex, "def")


def test_named_large_pattern():
    # Test with a large pattern (repetition)
    large_pattern = "a" * 500
    codeflash_output = named("group", large_pattern)
    regex = codeflash_output  # 1.12μs -> 777ns (44.5% faster)
    # Should match a string of 500 'a's
    match = re.match(regex, "a" * 500)


def test_named_many_unique_names():
    # Test creating many named groups to check for performance and correctness
    for i in range(100):
        name = f"group{i}"
        pattern = f"{i}a*"
        codeflash_output = named(name, pattern)
        regex = codeflash_output  # 22.9μs -> 17.3μs (32.0% faster)
        # Should match the correct number and any number of 'a's
        test_str = f"{i}" + "a" * i
        match = re.match(regex, test_str)


def test_named_long_group_name_and_pattern():
    # Test with long group name and pattern
    long_name = "group" * 50
    long_pattern = "a{1,1000}"
    codeflash_output = named(long_name, long_pattern)
    regex = codeflash_output  # 1.01μs -> 672ns (50.0% faster)
    # Should match a string of 1000 'a's
    match = re.match(regex, "a" * 1000)


def test_named_pattern_with_nested_groups_large():
    # Test with a pattern containing many nested groups
    nested_pattern = "(" * 50 + "a" + ")" * 50
    codeflash_output = named("deep", nested_pattern)
    regex = codeflash_output  # 888ns -> 649ns (36.8% faster)
    match = re.match(regex, "a")


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

⏪ Replay Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_pytest_xarrayteststest_concat_py_xarrayteststest_computation_py_xarrayteststest_formatting_py_xarray__replay_test_0.py::test_xarray_coding_cftimeindex_named	7.33μs	6.19μs	18.5%✅

To edit these changes git checkout codeflash/optimize-named-mir1h4hm and push.