⚡️ Speed up function parse_var by 26%

[codeflash-ai]

📄 26% (0.26x) speedup for parse_var in panel/command/serve.py

⏱️ Runtime : 574 microseconds → 454 microseconds (best of 43 runs)

📝 Explanation and details

The optimization replaces two inefficient operations with a single, more targeted one:

Key Change: s.split('=') + '='.join(items[1:]) → s.split('=', 1)

Why it's faster:

1. Reduced splitting overhead: The original code splits the entire string at every =, then rejoins everything after the first split. The optimized version uses split('=', 1) to split only at the first =, avoiding unnecessary work.

2. Eliminates string rejoining: The original code's '='.join(items[1:]) operation is completely eliminated. This string concatenation is expensive, especially when there are many = characters in the value.

3. Direct array access: Instead of reconstructing the value through joining, the optimized version simply accesses parts[1] directly.

Performance Impact by Test Type:

• Basic cases: 5-19% speedup due to eliminating the join operation
• Multiple equals in value: 18-47% speedup - the more = characters, the greater the benefit since the original code unnecessarily splits and rejoins them all
• Large scale with many equals: Up to 1147% speedup for strings with 500 = characters, where the original approach becomes extremely inefficient

The optimization is most effective when parsing strings with multiple = characters in the value portion, which is common in configuration parsing scenarios.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from panel.command.serve import parse_var

# unit tests

# 1. Basic Test Cases

def test_basic_simple_pair():
    # Simple key-value pair
    codeflash_output = parse_var("foo=bar") # 1.66μs -> 1.44μs (15.6% faster)

def test_basic_spaces_around_key():
    # Spaces around key should be stripped
    codeflash_output = parse_var("  foo  =bar") # 1.47μs -> 1.34μs (9.38% faster)

def test_basic_spaces_around_value():
    # Spaces around value should not be stripped
    codeflash_output = parse_var("foo=  bar  ") # 1.34μs -> 1.26μs (7.09% faster)

def test_basic_quotes_in_value():
    # Value with quotes should be preserved
    codeflash_output = parse_var('foo="hello world"') # 1.31μs -> 1.24μs (5.72% faster)

def test_basic_multiple_equals_in_value():
    # Value contains '=' characters
    codeflash_output = parse_var("foo=bar=baz=qux") # 1.48μs -> 1.25μs (18.6% faster)

def test_basic_empty_value():
    # Empty value after '='
    codeflash_output = parse_var("foo=") # 1.30μs -> 1.17μs (11.8% faster)

def test_basic_empty_key():
    # Empty key before '='
    codeflash_output = parse_var("=bar") # 1.32μs -> 1.15μs (14.2% faster)


def test_basic_spaces_around_equals():
    # Spaces around equals sign
    codeflash_output = parse_var(" foo = bar ") # 1.59μs -> 1.36μs (16.5% faster)

# 2. Edge Test Cases

def test_edge_only_equals():
    # Only '=' character
    codeflash_output = parse_var("=") # 1.37μs -> 1.20μs (14.3% faster)

def test_edge_multiple_equals_and_spaces():
    # Multiple '=' and spaces in key and value
    codeflash_output = parse_var("  =  =  =  ") # 1.64μs -> 1.31μs (25.3% faster)


def test_edge_key_is_spaces():
    # Key is only spaces, which should be stripped to empty string
    codeflash_output = parse_var("    =value") # 1.66μs -> 1.42μs (16.8% faster)

def test_edge_value_is_spaces():
    # Value is only spaces, should not be stripped
    codeflash_output = parse_var("key=    ") # 1.42μs -> 1.25μs (13.1% faster)

def test_edge_key_and_value_are_spaces():
    # Both key and value are spaces
    codeflash_output = parse_var("   =   ") # 1.41μs -> 1.24μs (13.4% faster)

def test_edge_value_with_leading_and_trailing_equals():
    # Value starts and ends with '='
    codeflash_output = parse_var("foo==bar=") # 1.63μs -> 1.18μs (37.7% faster)

def test_edge_key_with_equals():
    # Key contains '=' (should not be possible, but test anyway)
    codeflash_output = parse_var("a=b=c") # 1.47μs -> 1.23μs (19.6% faster)

def test_edge_unicode_characters():
    # Unicode characters in key and value
    codeflash_output = parse_var("ключ=значение") # 1.96μs -> 1.83μs (7.38% faster)

def test_edge_newline_in_value():
    # Value contains newline character
    codeflash_output = parse_var("foo=bar\nbaz") # 1.29μs -> 1.12μs (14.9% faster)

def test_edge_tab_in_key_and_value():
    # Tabs in key and value
    codeflash_output = parse_var("\tfoo\t=\tbar\t") # 1.35μs -> 1.32μs (2.58% faster)

def test_edge_key_and_value_are_empty():
    # Both key and value are empty
    codeflash_output = parse_var("=") # 1.30μs -> 1.25μs (4.07% faster)

def test_edge_value_is_none_string():
    # Value is string 'None'
    codeflash_output = parse_var("foo=None") # 1.32μs -> 1.22μs (7.92% faster)

def test_edge_key_is_none_string():
    # Key is string 'None'
    codeflash_output = parse_var("None=bar") # 1.30μs -> 1.19μs (9.24% faster)

def test_edge_equals_in_quotes():
    # '=' inside quotes in value
    codeflash_output = parse_var('foo="a=b=c"') # 1.64μs -> 1.11μs (47.4% faster)

# 3. Large Scale Test Cases

def test_large_many_equals():
    # Large value with many '=' characters
    key = "foo"
    value = "=".join(["bar"] * 500)
    s = f"{key}={value}"
    codeflash_output = parse_var(s) # 18.5μs -> 1.48μs (1147% faster)

def test_large_long_key_and_value():
    # Very long key and value
    key = "k" * 500
    value = "v" * 500
    s = f"{key}={value}"
    codeflash_output = parse_var(s) # 1.88μs -> 1.54μs (22.1% faster)

def test_large_many_key_value_pairs():
    # Simulate parsing many pairs in a loop
    for i in range(1000):
        k = f"key{i}"
        v = f"value{i}"
        s = f"{k}={v}"
        codeflash_output = parse_var(s) # 302μs -> 251μs (20.1% faster)

def test_large_key_with_spaces_and_long_value():
    # Key with spaces, long value
    key = "   longkey   "
    value = "x" * 999
    s = f"{key}={value}"
    codeflash_output = parse_var(s) # 2.06μs -> 1.58μs (30.1% faster)

def test_large_value_with_newlines():
    # Value with many newlines
    key = "foo"
    value = "\n".join(["bar"] * 500)
    s = f"{key}={value}"
    codeflash_output = parse_var(s) # 2.03μs -> 1.34μs (51.6% faster)

def test_large_empty_values():
    # Many keys with empty values
    for i in range(500):
        k = f"key{i}"
        s = f"{k}="
        codeflash_output = parse_var(s) # 150μs -> 126μs (19.2% faster)


#------------------------------------------------
import pytest  # used for our unit tests
from panel.command.serve import parse_var

# unit tests

# ---- BASIC TEST CASES ----

def test_basic_key_value():
    # Basic key=value pair
    codeflash_output = parse_var("foo=bar") # 1.52μs -> 1.40μs (8.05% faster)

def test_basic_key_value_with_spaces():
    # Spaces around key and value
    codeflash_output = parse_var(" foo = bar ") # 1.44μs -> 1.33μs (7.80% faster)

def test_basic_key_with_empty_value():
    # Key with empty value
    codeflash_output = parse_var("foo=") # 1.41μs -> 1.18μs (19.3% faster)


def test_basic_key_with_value_containing_equals():
    # Value contains '='
    codeflash_output = parse_var("foo=bar=baz") # 1.73μs -> 1.33μs (30.3% faster)

def test_basic_key_with_quoted_value():
    # Value is quoted
    codeflash_output = parse_var('foo="hello world"') # 1.38μs -> 1.22μs (12.9% faster)

def test_basic_key_with_spaces_in_value():
    # Value contains spaces
    codeflash_output = parse_var("foo=hello world") # 1.33μs -> 1.18μs (13.3% faster)

# ---- EDGE TEST CASES ----


def test_edge_only_equals():
    # Only '=' present
    codeflash_output = parse_var("=") # 1.60μs -> 1.38μs (15.9% faster)

def test_edge_multiple_equals_start():
    # Key is empty, value contains equals
    codeflash_output = parse_var("==bar") # 1.61μs -> 1.17μs (37.3% faster)

def test_edge_multiple_equals_end():
    # Value ends with '='
    codeflash_output = parse_var("foo=bar=") # 1.57μs -> 1.22μs (28.1% faster)

def test_edge_key_with_leading_trailing_spaces():
    # Key with leading/trailing spaces
    codeflash_output = parse_var("   foo   =bar") # 1.53μs -> 1.39μs (9.98% faster)

def test_edge_value_with_leading_trailing_spaces():
    # Value with leading/trailing spaces
    codeflash_output = parse_var("foo=   bar   ") # 1.29μs -> 1.26μs (2.06% faster)

def test_edge_key_is_space():
    # Key is a space character
    codeflash_output = parse_var(" =bar") # 1.45μs -> 1.27μs (14.1% faster)

def test_edge_value_is_space():
    # Value is a space character
    codeflash_output = parse_var("foo= ") # 1.31μs -> 1.18μs (10.6% faster)

def test_edge_key_and_value_are_spaces():
    # Key and value are spaces
    codeflash_output = parse_var("   =   ") # 1.46μs -> 1.29μs (12.8% faster)

def test_edge_key_is_empty_value_is_empty():
    # Both key and value are empty
    codeflash_output = parse_var("=") # 1.28μs -> 1.19μs (7.63% faster)

def test_edge_key_is_empty_value_is_nonempty():
    # Key is empty, value is non-empty
    codeflash_output = parse_var("=bar") # 1.29μs -> 1.15μs (11.8% faster)

def test_edge_unicode_characters():
    # Unicode in key and value
    codeflash_output = parse_var("ключ=значение") # 1.95μs -> 1.71μs (14.3% faster)

def test_edge_special_characters():
    # Special characters in key and value
    codeflash_output = parse_var("foo@#=bar$%^") # 1.35μs -> 1.19μs (13.3% faster)

def test_edge_key_is_only_spaces():
    # Key is only spaces
    codeflash_output = parse_var("   =bar") # 1.43μs -> 1.27μs (12.9% faster)

def test_edge_value_is_only_spaces():
    # Value is only spaces
    codeflash_output = parse_var("foo=   ") # 1.33μs -> 1.18μs (12.8% faster)



def test_edge_value_is_empty_string():
    # Value is empty string
    codeflash_output = parse_var("foo=") # 1.56μs -> 1.42μs (10.2% faster)

def test_edge_key_and_value_are_empty_strings():
    # Key and value are empty strings
    codeflash_output = parse_var("=") # 1.38μs -> 1.18μs (17.4% faster)

def test_edge_key_contains_equals():
    # Key contains equals, which is not possible in shell but let's test
    codeflash_output = parse_var("foo=bar=baz") # 1.55μs -> 1.23μs (26.8% faster)

# ---- LARGE SCALE TEST CASES ----

def test_large_scale_many_equals():
    # Value contains many '=' characters
    s = "key=" + "=".join(["value"] * 500)
    expected_value = "=".join(["value"] * 500)
    codeflash_output = parse_var(s) # 17.0μs -> 1.48μs (1049% faster)

def test_large_scale_long_key_and_value():
    # Very long key and value
    key = "k" * 500
    value = "v" * 500
    s = f"{key}={value}"
    codeflash_output = parse_var(s) # 1.77μs -> 1.53μs (15.8% faster)

def test_large_scale_key_with_spaces():
    # Key with many spaces, value normal
    key = " " * 250 + "foo" + " " * 250
    s = f"{key}=bar"
    codeflash_output = parse_var(s) # 1.91μs -> 1.90μs (0.158% faster)

def test_large_scale_value_with_spaces():
    # Value with many spaces
    value = " " * 500 + "bar" + " " * 500
    s = f"foo={value}"
    codeflash_output = parse_var(s) # 1.85μs -> 1.48μs (25.2% faster)

def test_large_scale_key_and_value_are_spaces():
    # Both key and value are long strings of spaces
    key = " " * 500
    value = " " * 500
    s = f"{key}={value}"
    codeflash_output = parse_var(s) # 2.20μs -> 1.87μs (17.5% faster)

def test_large_scale_key_value_with_special_chars():
    # Key and value with special characters, long strings
    key = "!@#" * 200
    value = "$%^" * 200
    s = f"{key}={value}"
    codeflash_output = parse_var(s) # 1.90μs -> 1.54μs (23.7% faster)

def test_large_scale_key_value_with_unicode():
    # Key and value with unicode, long strings
    key = "ключ" * 200
    value = "значение" * 200
    s = f"{key}={value}"
    codeflash_output = parse_var(s) # 2.95μs -> 2.29μs (28.7% faster)

To edit these changes git checkout codeflash/optimize-parse_var-mha3duut and push.