⚡️ Speed up function format_attrs by 93%

[codeflash-ai]

📄 93% (0.93x) speedup for format_attrs in xarray/coding/cftimeindex.py

⏱️ Runtime : 704 microseconds → 365 microseconds (best of 19 runs)

📝 Explanation and details

The optimization replaces dictionary-based string formatting with direct f-string concatenation, achieving a 93% speedup by eliminating intermediate data structures and their associated overhead.

Key Changes:

• Removed dictionary creation: The original code created an attrs dictionary with 4 key-value pairs, requiring memory allocation and hash table operations
• Eliminated list comprehension: The [f"{k}={v}" for k, v in attrs.items()] step created an intermediate list
• Direct f-string formatting: All attribute formatting is now done in a single f-string expression

Why This Is Faster:

• Fewer memory allocations: No dictionary or list creation reduces Python's object allocation overhead
• Reduced function calls: Eliminates .items(), list comprehension iteration, and .join() method calls
• Better CPU cache usage: Direct string concatenation is more cache-friendly than multiple object creations

Impact on Workloads:
The function is called from __repr__ methods of CFTimeIndex objects, which are frequently used in:

• Interactive debugging and data exploration (where repr is called often)
• String representations of time series data in xarray datasets
• Logging and display operations

Since repr methods are often called repeatedly during data analysis workflows, this optimization provides meaningful performance improvements for users working with time series data. The test results show consistent 50-117% speedups across various input types and sizes, with the largest gains on simple, frequently-encountered cases.

Test Case Performance:
The optimization performs best on typical use cases (75-117% faster) and maintains good performance even with large strings or special characters (37-95% faster), making it broadly beneficial across different workloads.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from xarray.coding.cftimeindex import format_attrs


# Helper class to mimic the expected index interface
class DummyIndex:
    def __init__(self, dtype, length, calendar, freq):
        self.dtype = dtype
        self._length = length
        self.calendar = calendar
        self.freq = freq

    def __len__(self):
        return self._length


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


def test_format_attrs_basic():
    # Test with standard attribute values
    idx = DummyIndex(dtype="datetime64[ns]", length=10, calendar="gregorian", freq="D")
    expected = "dtype='datetime64[ns]', length=10, calendar='gregorian', freq='D'"
    codeflash_output = format_attrs(idx)  # 4.47μs -> 2.26μs (98.2% faster)


def test_format_attrs_basic_empty_freq():
    # Test with empty frequency string
    idx = DummyIndex(dtype="datetime64[ns]", length=5, calendar="gregorian", freq="")
    expected = "dtype='datetime64[ns]', length=5, calendar='gregorian', freq=''"
    codeflash_output = format_attrs(idx)  # 3.97μs -> 2.14μs (85.8% faster)


def test_format_attrs_basic_none_freq():
    # Test with None frequency
    idx = DummyIndex(dtype="datetime64[ns]", length=3, calendar="gregorian", freq=None)
    expected = "dtype='datetime64[ns]', length=3, calendar='gregorian', freq=None"
    codeflash_output = format_attrs(idx)  # 3.87μs -> 2.10μs (84.0% faster)


def test_format_attrs_basic_int_length():
    # Test with length as integer 0
    idx = DummyIndex(dtype="datetime64[ns]", length=0, calendar="gregorian", freq="D")
    expected = "dtype='datetime64[ns]', length=0, calendar='gregorian', freq='D'"
    codeflash_output = format_attrs(idx)  # 3.82μs -> 2.07μs (84.5% faster)


def test_format_attrs_basic_separator_semicolon():
    # Test with custom separator
    idx = DummyIndex(
        dtype="datetime64[ns]", length=2, calendar="proleptic_gregorian", freq="M"
    )
    expected = (
        "dtype='datetime64[ns]'; length=2; calendar='proleptic_gregorian'; freq='M'"
    )
    codeflash_output = format_attrs(
        idx, separator="; "
    )  # 4.06μs -> 2.32μs (75.2% faster)


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


def test_format_attrs_edge_empty_calendar():
    # Test with empty calendar string
    idx = DummyIndex(dtype="datetime64[ns]", length=1, calendar="", freq="D")
    expected = "dtype='datetime64[ns]', length=1, calendar='', freq='D'"
    codeflash_output = format_attrs(idx)  # 3.75μs -> 1.97μs (90.3% faster)


def test_format_attrs_edge_none_calendar():
    # Test with None calendar
    idx = DummyIndex(dtype="datetime64[ns]", length=1, calendar=None, freq="D")
    expected = "dtype='datetime64[ns]', length=1, calendar=None, freq='D'"
    codeflash_output = format_attrs(idx)  # 4.03μs -> 1.86μs (116% faster)


def test_format_attrs_edge_special_characters():
    # Test with special characters in attributes
    idx = DummyIndex(dtype="weird'type", length=1, calendar="cal\nendar", freq='F"Q')
    expected = "dtype='weird\\'type', length=1, calendar='cal\\nendar', freq='F\"Q'"
    codeflash_output = format_attrs(idx)  # 4.34μs -> 2.08μs (109% faster)


def test_format_attrs_edge_non_string_dtype():
    # Test with non-string dtype (e.g., int)
    idx = DummyIndex(dtype=123, length=4, calendar="gregorian", freq="D")
    expected = "dtype='123', length=4, calendar='gregorian', freq='D'"
    codeflash_output = format_attrs(idx)  # 3.83μs -> 2.19μs (75.1% faster)


def test_format_attrs_edge_separator_long_string():
    # Test with a long separator string
    idx = DummyIndex(dtype="datetime64[ns]", length=2, calendar="gregorian", freq="D")
    sep = " |-| "
    expected = (
        "dtype='datetime64[ns]' |-| length=2 |-| calendar='gregorian' |-| freq='D'"
    )
    codeflash_output = format_attrs(
        idx, separator=sep
    )  # 4.09μs -> 2.26μs (81.0% faster)


def test_format_attrs_edge_separator_empty_string():
    # Test with empty separator (no spaces)
    idx = DummyIndex(dtype="datetime64[ns]", length=2, calendar="gregorian", freq="D")
    expected = "dtype='datetime64[ns]'length=2calendar='gregorian'freq='D'"
    codeflash_output = format_attrs(
        idx, separator=""
    )  # 3.89μs -> 2.25μs (72.8% faster)


def test_format_attrs_edge_separator_unicode():
    # Test with a unicode separator
    idx = DummyIndex(dtype="datetime64[ns]", length=2, calendar="gregorian", freq="D")
    sep = " ✦ "
    expected = "dtype='datetime64[ns]' ✦ length=2 ✦ calendar='gregorian' ✦ freq='D'"
    codeflash_output = format_attrs(
        idx, separator=sep
    )  # 4.46μs -> 2.77μs (61.2% faster)


def test_format_attrs_edge_len_raises():
    # Test that TypeError is raised if __len__ is not defined
    class NoLen:
        dtype = "datetime64[ns]"
        calendar = "gregorian"
        freq = "D"

    idx = NoLen()
    with pytest.raises(TypeError):
        format_attrs(idx)  # 1.84μs -> 1.86μs (1.13% slower)


def test_format_attrs_edge_missing_attr():
    # Test that AttributeError is raised if an attribute is missing
    class MissingAttr:
        dtype = "datetime64[ns]"
        calendar = "gregorian"

        def __len__(self):
            return 5

    idx = MissingAttr()
    with pytest.raises(AttributeError):
        format_attrs(idx)  # 3.35μs -> 3.20μs (4.94% faster)


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


def test_format_attrs_large_length():
    # Test with a large length (close to 1000)
    idx = DummyIndex(dtype="datetime64[ns]", length=999, calendar="gregorian", freq="D")
    expected = "dtype='datetime64[ns]', length=999, calendar='gregorian', freq='D'"
    codeflash_output = format_attrs(idx)  # 4.26μs -> 2.17μs (96.1% faster)


def test_format_attrs_large_custom_attrs():
    # Test with long strings for attributes
    long_dtype = "d" * 200
    long_calendar = "cal" * 300
    long_freq = "f" * 400
    idx = DummyIndex(
        dtype=long_dtype, length=100, calendar=long_calendar, freq=long_freq
    )
    expected = f"dtype='{long_dtype}', length=100, calendar='{long_calendar}', freq='{long_freq}'"
    codeflash_output = format_attrs(idx)  # 6.01μs -> 3.99μs (50.4% faster)


def test_format_attrs_large_separator():
    # Test with a large separator
    sep = "-" * 100
    idx = DummyIndex(dtype="dt", length=10, calendar="cal", freq="fq")
    expected = f"dtype='dt'{'-'*100}length=10{'-'*100}calendar='cal'{'-'*100}freq='fq'"
    codeflash_output = format_attrs(
        idx, separator=sep
    )  # 4.22μs -> 2.38μs (77.6% faster)


def test_format_attrs_large_many_calls():
    # Test calling format_attrs many times to check for memory leaks or statefulness
    idx = DummyIndex(dtype="datetime64[ns]", length=10, calendar="gregorian", freq="D")
    expected = "dtype='datetime64[ns]', length=10, calendar='gregorian', freq='D'"
    for _ in range(500):
        codeflash_output = format_attrs(idx)  # 482μs -> 222μs (117% faster)


def test_format_attrs_large_varied_types():
    # Test with various types for all attributes
    idx = DummyIndex(dtype=object, length=100, calendar=12345, freq=None)
    expected = "dtype='object', length=100, calendar=12345, freq=None"
    codeflash_output = format_attrs(idx)  # 5.23μs -> 3.01μs (74.1% faster)


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

import pytest
from xarray.coding.cftimeindex import format_attrs


# Helper class to simulate index objects
class DummyIndex:
    def __init__(self, dtype, length, calendar, freq):
        self.dtype = dtype
        self._len = length
        self.calendar = calendar
        self.freq = freq

    def __len__(self):
        return self._len


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


def test_basic_all_str_fields():
    # All fields are simple strings, typical case
    idx = DummyIndex(dtype="float64", length=10, calendar="gregorian", freq="D")
    expected = "dtype='float64', length=10, calendar='gregorian', freq='D'"
    codeflash_output = format_attrs(idx)  # 6.06μs -> 3.31μs (83.1% faster)


def test_basic_int_dtype():
    # dtype is an integer type
    idx = DummyIndex(dtype="int32", length=5, calendar="proleptic_gregorian", freq="M")
    expected = "dtype='int32', length=5, calendar='proleptic_gregorian', freq='M'"
    codeflash_output = format_attrs(idx)  # 4.05μs -> 2.15μs (88.6% faster)


def test_basic_separator_semicolon():
    # Custom separator
    idx = DummyIndex(dtype="float32", length=3, calendar="360_day", freq="A")
    expected = "dtype='float32'; length=3; calendar='360_day'; freq='A'"
    codeflash_output = format_attrs(
        idx, separator="; "
    )  # 4.35μs -> 2.44μs (77.9% faster)


def test_basic_freq_none():
    # freq is None
    idx = DummyIndex(dtype="float64", length=2, calendar="noleap", freq=None)
    expected = "dtype='float64', length=2, calendar='noleap', freq=None"
    codeflash_output = format_attrs(idx)  # 3.78μs -> 2.04μs (85.8% faster)


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


def test_edge_zero_length():
    # length is zero
    idx = DummyIndex(dtype="float64", length=0, calendar="gregorian", freq="D")
    expected = "dtype='float64', length=0, calendar='gregorian', freq='D'"
    codeflash_output = format_attrs(idx)  # 3.83μs -> 1.99μs (92.0% faster)


def test_edge_empty_strings():
    # calendar and freq are empty strings
    idx = DummyIndex(dtype="float64", length=1, calendar="", freq="")
    expected = "dtype='float64', length=1, calendar='', freq=''"
    codeflash_output = format_attrs(idx)  # 3.81μs -> 2.05μs (85.8% faster)


def test_edge_special_characters():
    # calendar and freq with special characters
    idx = DummyIndex(dtype="float64", length=7, calendar="cal\nendar", freq="F\req")
    expected = r"dtype='float64', length=7, calendar='cal\nendar', freq='F\req'"
    codeflash_output = format_attrs(idx)  # 4.20μs -> 2.45μs (71.2% faster)


def test_edge_separator_special():
    # Separator with special characters
    idx = DummyIndex(dtype="float64", length=4, calendar="gregorian", freq="D")
    sep = " | "
    expected = "dtype='float64' | length=4 | calendar='gregorian' | freq='D'"
    codeflash_output = format_attrs(
        idx, separator=sep
    )  # 4.21μs -> 2.10μs (100% faster)


def test_edge_non_string_dtype():
    # dtype is not a string (e.g., a type object)
    class MyType:
        def __str__(self):
            return "mytype"

        def __repr__(self):
            return "mytype"

    idx = DummyIndex(dtype=MyType(), length=2, calendar="gregorian", freq="D")
    # Should use str() on dtype
    expected = "dtype='mytype', length=2, calendar='gregorian', freq='D'"
    codeflash_output = format_attrs(idx)  # 4.83μs -> 2.96μs (63.0% faster)


def test_edge_calendar_none():
    # calendar is None
    idx = DummyIndex(dtype="float64", length=1, calendar=None, freq="D")
    expected = "dtype='float64', length=1, calendar=None, freq='D'"
    codeflash_output = format_attrs(idx)  # 3.81μs -> 1.91μs (99.6% faster)


def test_edge_freq_is_bool():
    # freq is a boolean
    idx = DummyIndex(dtype="float64", length=3, calendar="gregorian", freq=True)
    expected = "dtype='float64', length=3, calendar='gregorian', freq=True"
    codeflash_output = format_attrs(idx)  # 3.83μs -> 2.18μs (75.9% faster)


def test_edge_separator_empty():
    # Empty separator
    idx = DummyIndex(dtype="float64", length=1, calendar="gregorian", freq="D")
    expected = "dtype='float64'length=1calendar='gregorian'freq='D'"
    codeflash_output = format_attrs(
        idx, separator=""
    )  # 4.10μs -> 2.32μs (76.5% faster)


def test_edge_separator_unicode():
    # Unicode separator
    idx = DummyIndex(dtype="float64", length=1, calendar="gregorian", freq="D")
    sep = " 🧬 "
    expected = "dtype='float64' 🧬 length=1 🧬 calendar='gregorian' 🧬 freq='D'"
    codeflash_output = format_attrs(
        idx, separator=sep
    )  # 4.46μs -> 2.99μs (49.1% faster)


def test_edge_len_not_int():
    # __len__ returns a non-int (should raise TypeError)
    class BadLenIndex(DummyIndex):
        def __len__(self):
            return "not-an-int"

    idx = BadLenIndex(dtype="float64", length=1, calendar="gregorian", freq="D")
    with pytest.raises(TypeError):
        # Should fail when trying to format length as string of an int
        format_attrs(idx)  # 2.36μs -> 2.13μs (10.5% faster)


def test_edge_missing_attribute():
    # Index missing a required attribute (should raise AttributeError)
    class IncompleteIndex:
        def __init__(self):
            self.dtype = "float64"
            self.calendar = "gregorian"
            # freq missing

        def __len__(self):
            return 1

    idx = IncompleteIndex()
    with pytest.raises(AttributeError):
        format_attrs(idx)  # 3.15μs -> 3.02μs (4.41% faster)


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


def test_large_length():
    # Large index length
    idx = DummyIndex(dtype="float64", length=999, calendar="gregorian", freq="D")
    expected = "dtype='float64', length=999, calendar='gregorian', freq='D'"
    codeflash_output = format_attrs(idx)  # 4.17μs -> 2.36μs (76.4% faster)


def test_large_dtype_string():
    # Very long dtype string
    long_dtype = "float" + "x" * 900
    idx = DummyIndex(dtype=long_dtype, length=100, calendar="gregorian", freq="D")
    expected = f"dtype='{long_dtype}', length=100, calendar='gregorian', freq='D'"
    codeflash_output = format_attrs(idx)  # 4.29μs -> 2.20μs (95.0% faster)


def test_large_calendar_string():
    # Very long calendar string
    long_calendar = "cal" * 300
    idx = DummyIndex(dtype="float64", length=1, calendar=long_calendar, freq="D")
    expected = f"dtype='float64', length=1, calendar='{long_calendar}', freq='D'"
    codeflash_output = format_attrs(idx)  # 5.20μs -> 3.36μs (54.8% faster)


def test_large_separator():
    # Large separator string
    sep = "-" * 500
    idx = DummyIndex(dtype="float64", length=1, calendar="gregorian", freq="D")
    expected = f"dtype='float64'{sep}length=1{sep}calendar='gregorian'{sep}freq='D'"
    codeflash_output = format_attrs(
        idx, separator=sep
    )  # 4.34μs -> 2.45μs (77.3% faster)


def test_large_all_fields():
    # All fields are large strings
    big = "x" * 900
    idx = DummyIndex(dtype=big, length=999, calendar=big, freq=big)
    expected = f"dtype='{big}', length=999, calendar='{big}', freq='{big}'"
    codeflash_output = format_attrs(idx)  # 6.53μs -> 4.77μs (37.0% faster)


# -------------------------
# Miscellaneous/Mutation Tests
# -------------------------


def test_mutation_order_matters():
    # Changing order of attrs in function should fail this test
    idx = DummyIndex(dtype="float64", length=1, calendar="gregorian", freq="D")
    codeflash_output = format_attrs(idx)
    result = codeflash_output  # 4.00μs -> 2.04μs (96.6% faster)


def test_mutation_typo_in_key():
    # If any key is misspelled, this test will fail
    idx = DummyIndex(dtype="float64", length=1, calendar="gregorian", freq="D")
    codeflash_output = format_attrs(idx)
    result = codeflash_output  # 3.96μs -> 2.03μs (94.7% faster)


def test_mutation_separator_used_everywhere():
    # Separator should be used between all key-value pairs
    idx = DummyIndex(dtype="float64", length=1, calendar="gregorian", freq="D")
    sep = "##"
    codeflash_output = format_attrs(idx, separator=sep)
    result = codeflash_output  # 4.16μs -> 2.48μs (67.5% faster)


def test_mutation_repr_used_for_calendar_and_freq():
    # calendar and freq should use repr (quotes for strings, None, etc.)
    idx = DummyIndex(dtype="float64", length=1, calendar=None, freq=None)
    codeflash_output = format_attrs(idx)
    result = codeflash_output  # 3.85μs -> 1.99μs (92.8% faster)
    idx2 = DummyIndex(dtype="float64", length=1, calendar="gregorian", freq="D")
    codeflash_output = format_attrs(idx2)
    result2 = codeflash_output  # 1.78μs -> 956ns (86.0% faster)


# 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_format_attrs	44.5μs	38.2μs	16.6%✅

To edit these changes git checkout codeflash/optimize-format_attrs-mir2b6ny and push.