⚡️ Speed up function parse_timedelta by 5%

[codeflash-ai]

📄 5% (0.05x) speedup for parse_timedelta in panel/util/__init__.py

⏱️ Runtime : 7.97 milliseconds → 7.58 milliseconds (best of 44 runs)

📝 Explanation and details

The optimized code achieves a 5% speedup by eliminating unnecessary dictionary operations and reducing function call overhead:

Key optimizations:

1. Direct group access instead of groupdict(): Rather than calling parts.groupdict() which creates a dictionary and then iterating through all possible keys, the code uses parts.group() directly for each known field ('weeks', 'days', 'hours', 'minutes', 'seconds'). This avoids dictionary allocation and the overhead of the .items() iteration.

2. Conditional parameter building: Uses walrus operator (if (w := g('weeks')):) to both check for matches and assign values in one step, only adding matched fields to time_params. This eliminates the need to check every possible key with if p: inside a loop.

3. Early return optimization: Adds a fast path that returns dt.timedelta() immediately if no parameters matched, avoiding an unnecessary function call with an empty dictionary.

Performance benefits by test type:

• Invalid/empty strings show the largest gains (10-14% faster) due to reduced overhead when no matches are found
• Single unit parsing shows moderate gains (2-6% faster) from eliminating dictionary operations
• Multi-unit parsing shows consistent but smaller gains (~2-4% faster) as the optimization impact is diluted across multiple matched fields

The optimization is most effective for cases with few matched time units or invalid inputs, while maintaining identical behavior for all valid inputs.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import datetime as dt
import re

# imports
import pytest  # used for our unit tests
from panel.util.__init__ import parse_timedelta

_period_regex = re.compile(r'((?P<weeks>\d+?)w)?((?P<days>\d+?)d)?((?P<hours>\d+?)h)?((?P<minutes>\d+?)m)?((?P<seconds>\d+?\.?\d*?)s)?')
from panel.util.__init__ import parse_timedelta

# unit tests

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

def test_single_unit_seconds():
    # Test parsing seconds only
    codeflash_output = parse_timedelta("10s") # 7.88μs -> 7.94μs (0.705% slower)
    codeflash_output = parse_timedelta("1.5s") # 2.58μs -> 2.49μs (3.45% faster)
    codeflash_output = parse_timedelta("0s") # 1.81μs -> 1.91μs (4.83% slower)

def test_single_unit_minutes():
    # Test parsing minutes only
    codeflash_output = parse_timedelta("5m") # 6.45μs -> 6.26μs (3.02% faster)
    codeflash_output = parse_timedelta("0m") # 2.29μs -> 2.25μs (1.64% faster)

def test_single_unit_hours():
    # Test parsing hours only
    codeflash_output = parse_timedelta("2h") # 6.56μs -> 6.39μs (2.72% faster)
    codeflash_output = parse_timedelta("0h") # 2.20μs -> 2.32μs (5.08% slower)

def test_single_unit_days():
    # Test parsing days only
    codeflash_output = parse_timedelta("3d") # 5.58μs -> 5.65μs (1.26% slower)
    codeflash_output = parse_timedelta("0d") # 1.92μs -> 1.94μs (1.08% slower)

def test_single_unit_weeks():
    # Test parsing weeks only
    codeflash_output = parse_timedelta("4w") # 6.21μs -> 5.87μs (5.72% faster)
    codeflash_output = parse_timedelta("0w") # 2.35μs -> 2.24μs (5.23% faster)

def test_multiple_units():
    # Test parsing multiple units
    codeflash_output = parse_timedelta("2w3d4h5m6s") # 7.97μs -> 7.87μs (1.27% faster)
    codeflash_output = parse_timedelta("1d2h") # 3.34μs -> 3.22μs (3.51% faster)
    codeflash_output = parse_timedelta("5m30s") # 3.07μs -> 2.85μs (7.50% faster)
    codeflash_output = parse_timedelta("1w1d1h1m1s") # 2.66μs -> 2.77μs (3.76% slower)

def test_float_seconds():
    # Test parsing seconds with a float value
    codeflash_output = parse_timedelta("2.75s") # 6.07μs -> 5.68μs (6.83% faster)

def test_float_minutes():
    # Test parsing minutes with a float value
    codeflash_output = parse_timedelta("1.5m") # 4.55μs -> 4.31μs (5.76% faster)

def test_float_hours():
    # Test parsing hours with a float value
    codeflash_output = parse_timedelta("2.25h") # 4.66μs -> 4.29μs (8.58% faster)

def test_float_days():
    # Test parsing days with a float value
    codeflash_output = parse_timedelta("3.5d") # 4.32μs -> 4.33μs (0.139% slower)

def test_float_weeks():
    # Test parsing weeks with a float value
    codeflash_output = parse_timedelta("1.5w") # 4.23μs -> 4.19μs (0.954% faster)

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

def test_empty_string():
    # Test edge case: empty string should return None
    codeflash_output = parse_timedelta("") # 3.72μs -> 3.66μs (1.58% faster)

def test_invalid_string():
    # Test edge case: completely invalid string should return None
    codeflash_output = parse_timedelta("abc") # 4.20μs -> 4.03μs (4.19% faster)
    codeflash_output = parse_timedelta("10") # 2.27μs -> 2.06μs (10.3% faster)
    codeflash_output = parse_timedelta("10x") # 1.54μs -> 1.36μs (12.8% faster)
    codeflash_output = parse_timedelta("10 s") # 1.34μs -> 1.23μs (8.94% faster)

def test_partial_invalid_string():
    # Test edge case: valid and invalid parts, should fail (regex does not match)
    codeflash_output = parse_timedelta("1d2x") # 6.78μs -> 6.65μs (1.91% faster)

def test_missing_number():
    # Test edge case: missing number before unit
    codeflash_output = parse_timedelta("h") # 4.03μs -> 3.86μs (4.25% faster)
    codeflash_output = parse_timedelta("m") # 1.43μs -> 1.30μs (9.36% faster)
    codeflash_output = parse_timedelta("w") # 1.00μs -> 878ns (14.0% faster)
    codeflash_output = parse_timedelta("d") # 919ns -> 825ns (11.4% faster)
    codeflash_output = parse_timedelta("s") # 927ns -> 819ns (13.2% faster)

def test_leading_trailing_spaces():
    # Test edge case: leading/trailing spaces should not match
    codeflash_output = parse_timedelta(" 1h") # 3.85μs -> 3.66μs (5.20% faster)
    codeflash_output = parse_timedelta("1h ") # 4.88μs -> 4.87μs (0.164% faster)
    codeflash_output = parse_timedelta(" 1h ") # 1.30μs -> 1.14μs (13.9% faster)

def test_zero_all_units():
    # Test edge case: all units zero
    codeflash_output = parse_timedelta("0w0d0h0m0s") # 7.25μs -> 7.34μs (1.21% slower)

def test_order_of_units():
    # Test edge case: units in different order should not match (regex expects w,d,h,m,s order)
    codeflash_output = parse_timedelta("5m2h") # 6.82μs -> 6.64μs (2.65% faster)
    codeflash_output = parse_timedelta("6s5m") # 2.56μs -> 2.48μs (3.18% faster)
    codeflash_output = parse_timedelta("3d2w") # 2.71μs -> 2.57μs (5.45% faster)

def test_large_float():
    # Test edge case: large float value
    codeflash_output = parse_timedelta("1234567.89s") # 7.45μs -> 7.20μs (3.42% faster)

def test_multiple_same_unit():
    # Test edge case: multiple same units (should not match, regex only matches first occurrence)
    codeflash_output = parse_timedelta("1h2h") # 6.68μs -> 6.96μs (4.11% slower)
    codeflash_output = parse_timedelta("1d1d") # 2.65μs -> 2.56μs (3.40% faster)

def test_negative_values():
    # Test edge case: negative values (regex does not match negative numbers)
    codeflash_output = parse_timedelta("-1h") # 4.09μs -> 3.75μs (9.21% faster)
    codeflash_output = parse_timedelta("1h-2m") # 4.00μs -> 4.07μs (1.92% slower)

def test_decimal_without_leading_digit():
    # Test edge case: .5h should not match (regex expects at least one digit before decimal)
    codeflash_output = parse_timedelta(".5h") # 4.02μs -> 3.53μs (14.0% faster)

def test_large_number_of_units():
    # Test edge case: all units present with large values
    codeflash_output = parse_timedelta("999w999d999h999m999s") # 8.71μs -> 8.72μs (0.080% slower)

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

def test_large_scale_seconds():
    # Test large scale: seconds up to 999
    for i in range(0, 1000, 111):
        s = f"{i}s"
        expected = dt.timedelta(seconds=i)
        codeflash_output = parse_timedelta(s) # 19.5μs -> 18.3μs (6.19% faster)

def test_large_scale_combined_units():
    # Test large scale: combine units in increasing order
    for i in range(0, 1000, 250):
        s = f"{i}w{i}d{i}h{i}m{i}s"
        expected = dt.timedelta(weeks=i, days=i, hours=i, minutes=i, seconds=i)
        codeflash_output = parse_timedelta(s) # 15.1μs -> 14.9μs (0.993% faster)

def test_large_scale_float_seconds():
    # Test large scale: float seconds up to 999.9
    for i in range(0, 1000, 200):
        s = f"{i + 0.5}s"
        expected = dt.timedelta(seconds=i + 0.5)
        codeflash_output = parse_timedelta(s) # 12.7μs -> 11.7μs (8.69% faster)

def test_large_scale_performance():
    # Test performance: parse many valid strings in a row
    strings = [f"{i}h{i}m{i}s" for i in range(1, 1001)]
    for i, s in enumerate(strings, 1):
        expected = dt.timedelta(hours=i, minutes=i, seconds=i)
        codeflash_output = parse_timedelta(s) # 1.85ms -> 1.74ms (5.93% faster)

def test_large_scale_invalid_strings():
    # Test performance: parse many invalid strings in a row
    strings = [f"{i}x" for i in range(1, 1001)]
    for s in strings:
        codeflash_output = parse_timedelta(s) # 1.14ms -> 1.02ms (11.0% faster)

# --------------------
# Additional Robustness Tests
# --------------------

def test_mixed_integer_and_float_units():
    # Test mixed integer and float units
    codeflash_output = parse_timedelta("1w2.5d3h4.25m5.75s") # 8.38μs -> 8.24μs (1.71% faster)

def test_zero_and_nonzero_units():
    # Test mix of zero and nonzero units
    codeflash_output = parse_timedelta("0w0d2h0m3s") # 8.65μs -> 8.30μs (4.23% faster)

def test_maximum_supported_units():
    # Test maximum supported values for each unit (within reasonable range)
    codeflash_output = parse_timedelta("999w999d999h999m999.999s") # 9.40μs -> 9.14μs (2.80% faster)

def test_no_units():
    # Test string with no units
    codeflash_output = parse_timedelta("") # 4.09μs -> 3.98μs (2.84% faster)
    codeflash_output = parse_timedelta(" ") # 1.88μs -> 1.78μs (5.40% faster)

def test_only_partial_match():
    # Test string that partially matches but not fully
    codeflash_output = parse_timedelta("2h5") # 7.54μs -> 7.15μs (5.44% faster)
    codeflash_output = parse_timedelta("2h5x") # 2.81μs -> 2.78μs (1.15% faster)

def test_multiple_valid_strings():
    # Test parsing a list of valid strings
    valid_strings = [
        "1w", "2d", "3h", "4m", "5s",
        "1w2d3h4m5s", "10m20s", "0w0d0h0m0s"
    ]
    expected = [
        dt.timedelta(weeks=1),
        dt.timedelta(days=2),
        dt.timedelta(hours=3),
        dt.timedelta(minutes=4),
        dt.timedelta(seconds=5),
        dt.timedelta(weeks=1, days=2, hours=3, minutes=4, seconds=5),
        dt.timedelta(minutes=10, seconds=20),
        dt.timedelta(weeks=0, days=0, hours=0, minutes=0, seconds=0)
    ]
    for s, e in zip(valid_strings, expected):
        codeflash_output = parse_timedelta(s) # 21.1μs -> 20.1μs (4.93% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from __future__ import annotations

import datetime as dt
import re

# imports
import pytest  # used for our unit tests
from panel.util.__init__ import parse_timedelta

_period_regex = re.compile(r'((?P<weeks>\d+?)w)?((?P<days>\d+?)d)?((?P<hours>\d+?)h)?((?P<minutes>\d+?)m)?((?P<seconds>\d+?\.?\d*?)s)?')
from panel.util.__init__ import parse_timedelta

# unit tests

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

def test_parse_timedelta_single_unit_seconds():
    # Should parse seconds only
    codeflash_output = parse_timedelta("5s") # 7.49μs -> 7.61μs (1.55% slower)
    codeflash_output = parse_timedelta("0s") # 2.19μs -> 2.20μs (0.182% slower)
    codeflash_output = parse_timedelta("123.45s") # 2.93μs -> 2.57μs (13.8% faster)

def test_parse_timedelta_single_unit_minutes():
    # Should parse minutes only
    codeflash_output = parse_timedelta("10m") # 6.56μs -> 6.42μs (2.23% faster)
    codeflash_output = parse_timedelta("0m") # 2.49μs -> 2.31μs (7.79% faster)

def test_parse_timedelta_single_unit_hours():
    # Should parse hours only
    codeflash_output = parse_timedelta("2h") # 6.63μs -> 6.23μs (6.54% faster)
    codeflash_output = parse_timedelta("0h") # 2.31μs -> 2.19μs (5.33% faster)

def test_parse_timedelta_single_unit_days():
    # Should parse days only
    codeflash_output = parse_timedelta("3d") # 5.63μs -> 5.64μs (0.177% slower)
    codeflash_output = parse_timedelta("0d") # 1.98μs -> 2.02μs (1.69% slower)

def test_parse_timedelta_single_unit_weeks():
    # Should parse weeks only
    codeflash_output = parse_timedelta("4w") # 6.11μs -> 6.12μs (0.261% slower)
    codeflash_output = parse_timedelta("0w") # 2.18μs -> 2.30μs (5.56% slower)

def test_parse_timedelta_multiple_units():
    # Should parse multiple units combined
    codeflash_output = parse_timedelta("1w2d3h4m5s") # 8.07μs -> 7.91μs (2.06% faster)
    codeflash_output = parse_timedelta("2d5h") # 3.42μs -> 3.25μs (5.32% faster)
    codeflash_output = parse_timedelta("1h30m") # 2.88μs -> 2.70μs (6.89% faster)
    codeflash_output = parse_timedelta("3m15.5s") # 3.04μs -> 2.81μs (8.33% faster)
    codeflash_output = parse_timedelta("1w1d1h1m1s") # 2.71μs -> 2.64μs (2.80% faster)

def test_parse_timedelta_order_variation():
    # Should parse units in any order (since regex only matches in the defined order, these will fail)
    # But with current regex, only the defined order is matched, so these should return None
    codeflash_output = parse_timedelta("5s4m3h2d1w") # 5.54μs -> 5.62μs (1.44% slower)
    codeflash_output = parse_timedelta("1h2d") # 3.31μs -> 3.27μs (1.22% faster)

def test_parse_timedelta_empty_string():
    # Empty string should return None
    codeflash_output = parse_timedelta("") # 3.90μs -> 3.50μs (11.3% faster)

def test_parse_timedelta_no_units():
    # String with no valid units should return None
    codeflash_output = parse_timedelta("foobar") # 4.09μs -> 4.01μs (2.12% faster)
    codeflash_output = parse_timedelta("123") # 2.40μs -> 2.35μs (2.21% faster)

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

def test_parse_timedelta_leading_trailing_spaces():
    # Leading/trailing spaces should cause the regex to fail (since match is not fullmatch)
    codeflash_output = parse_timedelta(" 1h ") # 3.75μs -> 3.67μs (2.13% faster)

def test_parse_timedelta_partial_match():
    # Should not match if extra text is present
    codeflash_output = parse_timedelta("1hX") # 7.10μs -> 6.66μs (6.72% faster)
    codeflash_output = parse_timedelta("abc1h") # 1.86μs -> 1.81μs (2.70% faster)

def test_parse_timedelta_zero_all_units():
    # All units zero should return timedelta(0)
    codeflash_output = parse_timedelta("0w0d0h0m0s") # 7.43μs -> 7.30μs (1.73% faster)

def test_parse_timedelta_large_numbers():
    # Large values for each unit
    codeflash_output = parse_timedelta("999w888d777h666m555s") # 8.24μs -> 8.13μs (1.29% faster)

def test_parse_timedelta_decimal_seconds():
    # Should parse decimal seconds
    codeflash_output = parse_timedelta("1.25s") # 6.61μs -> 6.43μs (2.75% faster)
    codeflash_output = parse_timedelta("0.001s") # 2.44μs -> 2.40μs (1.29% faster)

def test_parse_timedelta_negative_numbers():
    # Negative numbers are not matched by the regex, so should return None
    codeflash_output = parse_timedelta("-1h") # 4.08μs -> 3.87μs (5.53% faster)
    codeflash_output = parse_timedelta("1h-30m") # 4.41μs -> 4.45μs (0.742% slower)

def test_parse_timedelta_double_units():
    # Should not allow repeated units (regex only matches first occurrence)
    codeflash_output = parse_timedelta("1h2h") # 7.05μs -> 6.85μs (2.83% faster)

def test_parse_timedelta_missing_numbers():
    # Should not match if number is missing
    codeflash_output = parse_timedelta("h") # 4.02μs -> 3.93μs (2.21% faster)
    codeflash_output = parse_timedelta("wm") # 1.68μs -> 1.54μs (8.94% faster)

def test_parse_timedelta_float_other_units():
    # Only seconds can be decimal (per regex)
    codeflash_output = parse_timedelta("1.5m") # 4.53μs -> 4.20μs (7.66% faster)
    codeflash_output = parse_timedelta("1.5h") # 1.71μs -> 1.52μs (12.7% faster)


def test_parse_timedelta_case_sensitivity():
    # Should be case sensitive, so "1H" is not valid
    codeflash_output = parse_timedelta("1H") # 5.70μs -> 5.58μs (2.21% faster)
    codeflash_output = parse_timedelta("1W2D") # 1.71μs -> 1.72μs (0.580% slower)

def test_parse_timedelta_partial_units():
    # Should not match partial units
    codeflash_output = parse_timedelta("1hour") # 7.50μs -> 7.47μs (0.428% faster)
    codeflash_output = parse_timedelta("2days") # 2.33μs -> 2.33μs (0.301% faster)

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

def test_parse_timedelta_long_valid_string():
    # Test a string with all units and large values
    s = "999w888d777h666m555.123s"
    expected = dt.timedelta(weeks=999, days=888, hours=777, minutes=666, seconds=555.123)
    codeflash_output = parse_timedelta(s) # 7.36μs -> 7.34μs (0.191% faster)

def test_parse_timedelta_many_calls():
    # Test function performance and correctness with many calls
    for i in range(1000):
        s = f"{i}w{i}d{i}h{i}m{i}s"
        expected = dt.timedelta(weeks=i, days=i, hours=i, minutes=i, seconds=i)
        codeflash_output = parse_timedelta(s) # 2.17ms -> 2.09ms (4.09% faster)

def test_parse_timedelta_large_seconds():
    # Test with a large number of seconds
    s = "999999999s"
    expected = dt.timedelta(seconds=999999999)
    codeflash_output = parse_timedelta(s) # 6.27μs -> 6.37μs (1.49% slower)

def test_parse_timedelta_large_combined():
    # Test with large values for all units
    s = "999w999d999h999m999s"
    expected = dt.timedelta(weeks=999, days=999, hours=999, minutes=999, seconds=999)
    codeflash_output = parse_timedelta(s) # 6.35μs -> 6.46μs (1.72% slower)

def test_parse_timedelta_many_zero_units():
    # Test with many zero units, should return timedelta(0)
    s = "0w0d0h0m0s"
    codeflash_output = parse_timedelta(s) # 7.25μs -> 7.05μs (2.94% faster)

def test_parse_timedelta_performance():
    # Test performance with 1000 different valid inputs
    for i in range(1000):
        s = f"{i}w{i}d{i}h{i}m{i}.123s"
        expected = dt.timedelta(weeks=i, days=i, hours=i, minutes=i, seconds=i + 0.123)
        codeflash_output = parse_timedelta(s) # 2.31ms -> 2.23ms (3.49% faster)

# ----------------------
# Miscellaneous
# ----------------------

def test_parse_timedelta_none_input():
    # Should raise TypeError on None input
    with pytest.raises(TypeError):
        parse_timedelta(None) # 1.63μs -> 1.69μs (3.50% slower)

def test_parse_timedelta_non_string_input():
    # Should raise TypeError on non-string input
    with pytest.raises(TypeError):
        parse_timedelta(123) # 1.48μs -> 1.57μs (5.81% slower)
    with pytest.raises(TypeError):
        parse_timedelta(12.5) # 797ns -> 770ns (3.51% faster)
    with pytest.raises(TypeError):
        parse_timedelta(['1h']) # 531ns -> 533ns (0.375% slower)

def test_parse_timedelta_repr():
    # Check that the returned object is always timedelta or None
    codeflash_output = parse_timedelta("1h"); result = codeflash_output # 7.96μs -> 7.97μs (0.201% slower)
    codeflash_output = parse_timedelta("badinput"); result = codeflash_output # 2.00μs -> 1.96μs (1.84% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from panel.util.__init__ import parse_timedelta
import pytest

def test_parse_timedelta():
    parse_timedelta('')

def test_parse_timedelta_2():
    with pytest.raises(TypeError, match="float\\(\\)\\ argument\\ must\\ be\\ a\\ string\\ or\\ a\\ real\\ number,\\ not\\ 'tuple'"):
        parse_timedelta('০d')

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_kzgds56_/tmp1jqmerx3/test_concolic_coverage.py::test_parse_timedelta	3.91μs	3.44μs	13.6%✅

To edit these changes git checkout codeflash/optimize-parse_timedelta-mha468vi and push.