⚡️ Speed up function CONTEXTUAL_TIMEDELTA_FORMATTER by 24%

[codeflash-ai]

📄 24% (0.24x) speedup for CONTEXTUAL_TIMEDELTA_FORMATTER in src/bokeh/models/formatters.py

⏱️ Runtime : 6.16 milliseconds → 4.98 milliseconds (best of 16 runs)

📝 Explanation and details

The optimization achieves a 23% speedup by precomputing the constant keyword argument dictionaries used to construct nested TimedeltaTickFormatter objects, avoiding repeated allocation overhead on each function call.

Key Optimizations:

1. Precomputed Static Dictionaries: The original code recreated identical dictionaries and lists every time the function was called. The optimized version moves these constant values into module-level variables (_base_kwargs, _ctx1_kwargs, _ctx2_kwargs) that are computed once at import time.

2. Reduced Memory Allocations: Instead of constructing nested keyword arguments inline (which creates temporary dictionaries at each nesting level), the optimization uses .copy() on pre-existing dictionaries and modifies only the context field as needed.

3. Eliminated Redundant Object Creation: The original version created three levels of nested TimedeltaTickFormatter objects in a single expression, causing the Python interpreter to allocate memory for intermediate keyword dictionaries multiple times. The optimized version builds these objects step-by-step, reusing pre-allocated dictionaries.

Performance Impact:
The line profiler shows that the three TimedeltaTickFormatter constructor calls (lines with ~31-35% of total time) are now more efficient because they use pre-allocated dictionaries rather than constructing new ones from scratch. The optimization is particularly effective for this use case because the formatter configuration is completely static - the same values are used every time.

Test Results Analysis:
All test cases show consistent 19-28% improvements, indicating the optimization is effective regardless of the specific formatting scenarios being tested. The performance gain is most pronounced in test_context_nested_formatting (27.6% faster), which makes sense as it directly exercises the nested formatter construction that was optimized.

This optimization is especially valuable if CONTEXTUAL_TIMEDELTA_FORMATTER() is called frequently in data visualization workflows where tick formatters are created repeatedly.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from datetime import timedelta

# imports
import pytest
from bokeh.models.formatters import CONTEXTUAL_TIMEDELTA_FORMATTER

# For the purposes of this test suite, we'll define a minimal TimedeltaTickFormatter
# and CONTEXTUAL_TIMEDELTA_FORMATTER with the expected formatting logic.
# In a real scenario, these would be imported from bokeh.models.formatters.

class TimedeltaTickFormatter:
    def __init__(self, nanoseconds="%NSns", microseconds="%USus", milliseconds="%MSms",
                 seconds="%H:%M:%S", minsec="%H:%M:%S", minutes="%H:%M", hourmin="%H:%M",
                 hours="%H:%M", days="%d days", strip_leading_zeros=None, context_which="all",
                 context=None, hide_repeats=False):
        self.nanoseconds = nanoseconds
        self.microseconds = microseconds
        self.milliseconds = milliseconds
        self.seconds = seconds
        self.minsec = minsec
        self.minutes = minutes
        self.hourmin = hourmin
        self.hours = hours
        self.days = days
        self.strip_leading_zeros = strip_leading_zeros or []
        self.context_which = context_which
        self.context = context
        self.hide_repeats = hide_repeats

    def format(self, td: timedelta, unit: str = None):
        # For test purposes, a simplified formatter that only handles a subset of cases
        total_seconds = int(td.total_seconds())
        days = td.days
        seconds = td.seconds
        microseconds = td.microseconds
        hours, remainder = divmod(seconds, 3600)
        minutes, seconds = divmod(remainder, 60)
        ms = microseconds // 1000
        us = microseconds % 1000
        ns = 0  # timedelta doesn't support nanoseconds, so we use 0

        # Pick format string
        fmt = getattr(self, unit or "seconds")
        # Replace tokens
        fmt = fmt.replace("%d", str(days))
        fmt = fmt.replace("%H", f"{hours:02d}")
        fmt = fmt.replace("%M", f"{minutes:02d}")
        fmt = fmt.replace("%S", f"{seconds:02d}")
        fmt = fmt.replace("%MS", f"{ms:03d}")
        fmt = fmt.replace("%US", f"{us:03d}")
        fmt = fmt.replace("%NS", f"{ns:03d}")
        return fmt
from bokeh.models.formatters import CONTEXTUAL_TIMEDELTA_FORMATTER

# ========== Unit Tests ==========

# 1. Basic Test Cases











def test_large_timedelta():
    # Test formatting for very large timedelta (e.g., 999 days)
    codeflash_output = CONTEXTUAL_TIMEDELTA_FORMATTER(); fmt = codeflash_output # 843μs -> 688μs (22.5% faster)
    td = timedelta(days=999, hours=23, minutes=59, seconds=59)


def test_subsecond_timedelta():
    # Test formatting for subsecond values
    codeflash_output = CONTEXTUAL_TIMEDELTA_FORMATTER(); fmt = codeflash_output # 917μs -> 745μs (23.0% faster)
    td = timedelta(microseconds=999)
    td = timedelta(milliseconds=999)

def test_strip_leading_zeros():
    # Test that leading zeros are stripped for certain units (mock implementation)
    codeflash_output = CONTEXTUAL_TIMEDELTA_FORMATTER(); fmt = codeflash_output # 821μs -> 688μs (19.3% faster)
    td = timedelta(microseconds=1)

def test_context_nested_formatting():
    # Test that context formatter is properly nested (mock: just check attribute exists)
    codeflash_output = CONTEXTUAL_TIMEDELTA_FORMATTER(); fmt = codeflash_output # 869μs -> 681μs (27.6% faster)

def test_unusual_units():
    # Test behavior with an unknown unit (should raise AttributeError)
    codeflash_output = CONTEXTUAL_TIMEDELTA_FORMATTER(); fmt = codeflash_output # 855μs -> 691μs (23.7% faster)
    td = timedelta(seconds=1)
    with pytest.raises(AttributeError):
        fmt.format(td, unit="fortnights")

# 3. Large Scale Test Cases



def test_context_chain_large_scale():
    # Test that context chain does not break with large chain (mock: depth 3)
    codeflash_output = CONTEXTUAL_TIMEDELTA_FORMATTER(); fmt = codeflash_output # 914μs -> 745μs (22.7% faster)
    c1 = fmt.context
    c2 = c1.context
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from datetime import timedelta

# imports
import pytest
from bokeh.models.formatters import CONTEXTUAL_TIMEDELTA_FORMATTER


# Minimal stub for TimedeltaTickFormatter for testing purposes
class TimedeltaTickFormatter:
    def __init__(self, nanoseconds="%NSns", microseconds="%USus", milliseconds="%MSms",
                 seconds="%H:%M:%S", minsec="%H:%M:%S", minutes="%H:%M", hourmin="%H:%M",
                 hours="%H:%M", days="%d days", strip_leading_zeros=None, context_which="all",
                 context=None, hide_repeats=False):
        self.nanoseconds = nanoseconds
        self.microseconds = microseconds
        self.milliseconds = milliseconds
        self.seconds = seconds
        self.minsec = minsec
        self.minutes = minutes
        self.hourmin = hourmin
        self.hours = hours
        self.days = days
        self.strip_leading_zeros = strip_leading_zeros or []
        self.context_which = context_which
        self.context = context
        self.hide_repeats = hide_repeats

    def format(self, td: timedelta) -> str:
        # This method simulates contextual formatting based on the magnitude of the timedelta.
        total_seconds = td.total_seconds()
        abs_td = abs(td)
        days = abs_td.days
        seconds = abs_td.seconds
        microseconds = abs_td.microseconds
        nanoseconds = 0  # Python timedelta doesn't support nanoseconds, but for tests we can simulate

        # Context selection
        # For simplicity, we simulate context switching for large/small values.
        if days > 0:
            fmt = self.days
            if fmt == "":
                return ""
            return fmt.replace("%d", str(days))
        elif seconds >= 3600:
            fmt = self.hours
            h = seconds // 3600
            m = (seconds % 3600) // 60
            return fmt.replace("%H", f"{h:02d}").replace("%M", f"{m:02d}")
        elif seconds >= 60:
            fmt = self.minutes
            m = seconds // 60
            return fmt.replace("%H", "00").replace("%M", f"{m:02d}")
        elif seconds > 0:
            fmt = self.seconds
            h = seconds // 3600
            m = (seconds % 3600) // 60
            s = seconds % 60
            return fmt.replace("%H", f"{h:02d}").replace("%M", f"{m:02d}").replace("%S", f"{s:02d}")
        elif microseconds >= 1000:
            fmt = self.milliseconds
            ms = microseconds // 1000
            return fmt.replace("%MS", f"{ms:03d}")
        elif microseconds > 0:
            fmt = self.microseconds
            us = microseconds
            return fmt.replace("%US", f"{us:06d}")
        else:
            fmt = self.nanoseconds
            ns = nanoseconds
            return fmt.replace("%NS", f"{ns:09d}")
from bokeh.models.formatters import CONTEXTUAL_TIMEDELTA_FORMATTER

# ------------------- UNIT TESTS -------------------

# 1. Basic Test Cases

from bokeh.models.formatters import CONTEXTUAL_TIMEDELTA_FORMATTER

To edit these changes git checkout codeflash/optimize-CONTEXTUAL_TIMEDELTA_FORMATTER-mhwgx7xw and push.