⚡️ Speed up function _parse_latex_table_styles by 36%

[codeflash-ai]

📄 36% (0.36x) speedup for _parse_latex_table_styles in pandas/io/formats/style_render.py

⏱️ Runtime : 152 microseconds → 112 microseconds (best of 47 runs)

📝 Explanation and details

The optimization replaces table_styles[::-1] with reversed(table_styles) in the loop iteration. This is a classic Python performance improvement that eliminates unnecessary memory allocation and copying.

Key change: The slice operation [::-1] creates a complete reversed copy of the list in memory, requiring O(n) time and space. The reversed() built-in function returns an iterator that traverses the list backwards without creating a copy, using O(1) memory and minimal overhead.

Why this leads to speedup:

• Memory efficiency: No intermediate reversed list is created, reducing memory allocations
• Time efficiency: Eliminates the O(n) copying operation that happens on every function call
• Iterator overhead: The reversed() iterator has very low per-iteration cost compared to list indexing

Performance impact based on test results:

• Small lists (1-10 items): 17-40% speedup, showing the overhead reduction even for minimal data
• Large lists (500-1000 items): 83-468% speedup, demonstrating the optimization scales significantly with input size
• No-match scenarios: 10-30% speedup, proving the benefit applies regardless of early termination

The line profiler shows the loop initialization time decreased from 431μs to 393μs (9% improvement), and the total function runtime improved by 36%. This optimization is particularly valuable for styling operations in pandas DataFrames where table styles can contain hundreds of CSS rules, making the memory and time savings substantial in data processing pipelines.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
io/formats/style/test_to_latex.py::test_parse_latex_table_styles	2.81μs	2.53μs	11.3%✅

🌀 Generated Regression Tests and Runtime

from typing import Union

# imports
import pytest  # used for our unit tests
from pandas.io.formats.style_render import _parse_latex_table_styles

CSSPair = tuple[str, Union[str, float]]
CSSList = list[CSSPair]
CSSDict = dict[str, Union[str, CSSList]]
CSSStyles = list[CSSDict]

# unit tests

# 1. Basic Test Cases


def test_basic_single_match():
    # Basic: Only one style, selector matches
    table_styles = [{"selector": "foo", "props": [("attr", "value")]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 1.66μs -> 1.33μs (25.1% faster)


def test_basic_no_match():
    # Basic: Only one style, selector does not match
    table_styles = [{"selector": "foo", "props": [("attr", "value")]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "bar"
    )  # 1.00μs -> 711ns (40.8% faster)


def test_basic_multiple_styles_first_match():
    # Basic: Multiple styles, selector matches first
    table_styles = [
        {"selector": "foo", "props": [("attr", "value")]},
        {"selector": "bar", "props": [("attr", "baz")]},
    ]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "bar"
    )  # 1.45μs -> 1.11μs (30.3% faster)


def test_basic_multiple_styles_last_match():
    # Basic: Multiple styles, selector matches last
    table_styles = [
        {"selector": "foo", "props": [("attr", "value")]},
        {"selector": "bar", "props": [("attr", "baz")]},
        {"selector": "bar", "props": [("attr", "qux")]},
    ]
    # Should pick the last (most recently applied) matching selector
    codeflash_output = _parse_latex_table_styles(
        table_styles, "bar"
    )  # 1.46μs -> 1.13μs (29.4% faster)


def test_basic_multiple_props_in_style():
    # Basic: Multiple props, should pick first prop's value
    table_styles = [
        {"selector": "foo", "props": [("attr", "value1"), ("attr2", "value2")]}
    ]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 1.44μs -> 1.09μs (32.5% faster)


def test_basic_type_conversion():
    # Basic: Value is not a string, should convert to string
    table_styles = [{"selector": "foo", "props": [("attr", 123.45)]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 3.31μs -> 2.89μs (14.4% faster)


def test_basic_replace_section_sign():
    # Basic: Value contains section sign, should replace with colon
    table_styles = [{"selector": "foo", "props": [("attr", "abc§def")]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 1.98μs -> 1.61μs (22.7% faster)


# 2. Edge Test Cases


def test_edge_empty_table_styles():
    # Edge: Empty table_styles list
    table_styles = []
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 790ns -> 521ns (51.6% faster)


def test_edge_empty_props_list():
    # Edge: Style with empty props list
    table_styles = [{"selector": "foo", "props": []}]
    # Should raise IndexError as per implementation, since it tries to access [0][1]
    with pytest.raises(IndexError):
        _parse_latex_table_styles(
            table_styles, "foo"
        )  # 1.50μs -> 1.22μs (22.9% faster)


def test_edge_missing_selector_key():
    # Edge: Style dict missing 'selector' key
    table_styles = [{"props": [("attr", "value")]}]
    # Should raise KeyError
    with pytest.raises(KeyError):
        _parse_latex_table_styles(table_styles, "foo")  # 1.25μs -> 997ns (24.9% faster)


def test_edge_missing_props_key():
    # Edge: Style dict missing 'props' key
    table_styles = [{"selector": "foo"}]
    # Should raise KeyError
    with pytest.raises(KeyError):
        _parse_latex_table_styles(
            table_styles, "foo"
        )  # 1.47μs -> 1.14μs (28.2% faster)


def test_edge_props_tuple_wrong_length():
    # Edge: 'props' contains tuple of wrong length
    table_styles = [{"selector": "foo", "props": [("onlyone",)]}]
    # Should raise IndexError when trying to access [0][1]
    with pytest.raises(IndexError):
        _parse_latex_table_styles(
            table_styles, "foo"
        )  # 1.77μs -> 1.51μs (16.8% faster)


def test_edge_selector_is_empty_string():
    # Edge: Selector is empty string
    table_styles = [{"selector": "", "props": [("attr", "empty")]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, ""
    )  # 1.49μs -> 1.16μs (28.4% faster)


def test_edge_selector_is_none():
    # Edge: Selector is None
    table_styles = [{"selector": None, "props": [("attr", "none")]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, None
    )  # 1.47μs -> 1.21μs (21.8% faster)


def test_edge_props_value_is_none():
    # Edge: Value in props is None
    table_styles = [{"selector": "foo", "props": [("attr", None)]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 1.55μs -> 1.24μs (25.8% faster)


def test_edge_multiple_matching_selectors():
    # Edge: Multiple matching selectors, should pick last
    table_styles = [
        {"selector": "foo", "props": [("attr", "first")]},
        {"selector": "foo", "props": [("attr", "second")]},
        {"selector": "foo", "props": [("attr", "third")]},
    ]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 1.43μs -> 1.14μs (25.8% faster)


def test_edge_props_value_with_multiple_section_signs():
    # Edge: Value contains multiple section signs
    table_styles = [{"selector": "foo", "props": [("attr", "a§b§c§d")]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 1.89μs -> 1.50μs (25.9% faster)


def test_edge_selector_not_string():
    # Edge: Selector is not a string (e.g., int)
    table_styles = [{"selector": 42, "props": [("attr", "answer")]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, 42
    )  # 1.39μs -> 1.03μs (35.6% faster)


# 3. Large Scale Test Cases


def test_large_many_styles_one_match():
    # Large: Many styles, only one matches
    table_styles = []
    # Add 999 non-matching styles
    for i in range(999):
        table_styles.append({"selector": f"foo{i}", "props": [("attr", f"value{i}")]})
    # Add one matching style at the end
    table_styles.append({"selector": "target", "props": [("attr", "winner")]})
    codeflash_output = _parse_latex_table_styles(
        table_styles, "target"
    )  # 4.28μs -> 1.51μs (183% faster)


def test_large_many_matching_styles():
    # Large: Many matching styles, should pick last
    table_styles = []
    for i in range(900):
        table_styles.append({"selector": "foo", "props": [("attr", f"value{i}")]})
    table_styles.append({"selector": "foo", "props": [("attr", "lastvalue")]})
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 3.72μs -> 1.36μs (174% faster)


def test_large_styles_with_section_signs():
    # Large: Many styles, some with section signs
    table_styles = []
    for i in range(500):
        table_styles.append({"selector": "bar", "props": [("attr", f"val§{i}")]})
    # Should get the last one, with section sign replaced
    codeflash_output = _parse_latex_table_styles(
        table_styles, "bar"
    )  # 3.25μs -> 1.77μs (83.1% faster)


def test_large_styles_with_varied_types():
    # Large: Many styles, with varied value types
    table_styles = []
    for i in range(300):
        if i % 3 == 0:
            val = i
        elif i % 3 == 1:
            val = float(i)
        else:
            val = f"str§{i}"
        table_styles.append({"selector": "baz", "props": [("attr", val)]})
    # Should get the last one, which is a string with section sign replaced
    codeflash_output = _parse_latex_table_styles(
        table_styles, "baz"
    )  # 2.76μs -> 1.65μs (67.0% faster)


def test_large_no_matching_selector():
    # Large: Many styles, none match selector
    table_styles = [
        {"selector": f"foo{i}", "props": [("attr", f"value{i}")]} for i in range(1000)
    ]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "notfound"
    )  # 25.8μs -> 23.2μs (11.2% faster)


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

from typing import Union

# imports
import pytest  # used for our unit tests
from pandas.io.formats.style_render import _parse_latex_table_styles

CSSPair = tuple[str, Union[str, float]]
CSSList = list[CSSPair]
CSSDict = dict[str, Union[str, CSSList]]
CSSStyles = list[CSSDict]

# unit tests

# 1. Basic Test Cases


def test_single_style_match():
    # Single style, selector matches
    table_styles = [{"selector": "foo", "props": [("attr", "value")]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 1.44μs -> 1.23μs (17.2% faster)


def test_single_style_no_match():
    # Single style, selector does not match
    table_styles = [{"selector": "foo", "props": [("attr", "value")]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "bar"
    )  # 944ns -> 723ns (30.6% faster)


def test_multiple_styles_first_match():
    # Multiple styles, selector matches only first
    table_styles = [
        {"selector": "foo", "props": [("attr", "value1")]},
        {"selector": "bar", "props": [("attr", "value2")]},
    ]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "bar"
    )  # 1.47μs -> 1.12μs (30.3% faster)


def test_multiple_styles_last_match():
    # Multiple styles, selector matches last
    table_styles = [
        {"selector": "foo", "props": [("attr", "value1")]},
        {"selector": "bar", "props": [("attr", "value2")]},
        {"selector": "bar", "props": [("attr", "value3")]},
    ]
    # Should return value3 (from the last matching style)
    codeflash_output = _parse_latex_table_styles(
        table_styles, "bar"
    )  # 1.44μs -> 1.08μs (33.0% faster)


def test_props_with_multiple_pairs():
    # Props has multiple pairs, only first is used
    table_styles = [
        {"selector": "foo", "props": [("attr", "first"), ("other", "second")]}
    ]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 1.40μs -> 1.07μs (30.9% faster)


def test_return_type_is_str():
    # Value is int/float, should be cast to str
    table_styles = [{"selector": "foo", "props": [("attr", 123)]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 1.51μs -> 1.21μs (24.9% faster)
    table_styles = [{"selector": "foo", "props": [("attr", 4.56)]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 2.05μs -> 1.98μs (3.44% faster)


# 2. Edge Test Cases


def test_empty_table_styles():
    # Empty input list
    codeflash_output = _parse_latex_table_styles(
        [], "foo"
    )  # 690ns -> 531ns (29.9% faster)


def test_selector_not_present():
    # Selector not present at all
    table_styles = [
        {"selector": "bar", "props": [("attr", "value")]},
        {"selector": "baz", "props": [("attr", "value2")]},
    ]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 1.00μs -> 805ns (24.5% faster)


def test_empty_props_list():
    # Props list is empty for matching selector
    table_styles = [{"selector": "foo", "props": []}]
    # Should raise IndexError, but function will fail. Let's catch it.
    with pytest.raises(IndexError):
        _parse_latex_table_styles(
            table_styles, "foo"
        )  # 1.48μs -> 1.19μs (25.1% faster)


def test_props_with_empty_tuple():
    # Props contains an empty tuple
    table_styles = [{"selector": "foo", "props": [("", "")]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 1.38μs -> 1.14μs (21.9% faster)


def test_selector_case_sensitivity():
    # Selector is case sensitive
    table_styles = [
        {"selector": "Foo", "props": [("attr", "upper")]},
        {"selector": "foo", "props": [("attr", "lower")]},
    ]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "Foo"
    )  # 1.55μs -> 1.26μs (23.5% faster)
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 587ns -> 529ns (11.0% faster)


def test_value_with_special_char_replacement():
    # Value contains "§" which should be replaced with ":"
    table_styles = [{"selector": "foo", "props": [("attr", "val§ue")]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 1.70μs -> 1.48μs (14.6% faster)


def test_value_with_multiple_special_chars():
    # Value contains multiple "§"
    table_styles = [{"selector": "foo", "props": [("attr", "§start§middle§end§")]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 1.83μs -> 1.60μs (14.4% faster)


def test_selector_with_empty_string():
    # Selector is empty string
    table_styles = [{"selector": "", "props": [("attr", "empty")]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, ""
    )  # 1.29μs -> 1.03μs (24.9% faster)


def test_props_with_non_string_value():
    # Props value is a float, should be converted to string
    table_styles = [{"selector": "foo", "props": [("attr", 3.1415)]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 2.75μs -> 2.60μs (5.93% faster)


def test_selector_with_whitespace():
    # Selector contains whitespace
    table_styles = [{"selector": "foo bar", "props": [("attr", "space")]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo bar"
    )  # 1.34μs -> 1.12μs (19.6% faster)


def test_props_with_tuple_of_length_more_than_two():
    # Props contains tuple with more than two elements, only first two used
    table_styles = [{"selector": "foo", "props": [("attr", "value", "extra")]}]
    # Should still return "value"
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 1.37μs -> 1.10μs (25.0% faster)


def test_props_with_tuple_of_length_one():
    # Props contains tuple with only one element, should raise IndexError
    table_styles = [{"selector": "foo", "props": [("only_one",)]}]
    with pytest.raises(IndexError):
        _parse_latex_table_styles(
            table_styles, "foo"
        )  # 1.59μs -> 1.31μs (21.5% faster)


def test_selector_is_none():
    # Selector is None, should not match any string selector
    table_styles = [{"selector": "foo", "props": [("attr", "value")]}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, None
    )  # 1.04μs -> 750ns (38.9% faster)


def test_missing_selector_key():
    # Style dict missing 'selector' key, should raise KeyError
    table_styles = [{"props": [("attr", "value")]}]
    with pytest.raises(KeyError):
        _parse_latex_table_styles(
            table_styles, "foo"
        )  # 1.29μs -> 1.09μs (18.7% faster)


def test_missing_props_key():
    # Style dict missing 'props' key, should raise KeyError
    table_styles = [{"selector": "foo"}]
    with pytest.raises(KeyError):
        _parse_latex_table_styles(
            table_styles, "foo"
        )  # 1.44μs -> 1.21μs (19.4% faster)


# 3. Large Scale Test Cases


def test_large_number_of_styles_last_match():
    # Large number of styles, selector matches only last
    table_styles = [
        {"selector": f"sel{i}", "props": [("attr", f"val{i}")]} for i in range(999)
    ]
    table_styles.append({"selector": "target", "props": [("attr", "final_value")]})
    codeflash_output = _parse_latex_table_styles(
        table_styles, "target"
    )  # 4.23μs -> 1.45μs (192% faster)


def test_large_number_of_styles_multiple_matches():
    # Large number of styles, selector matches multiple times, should return last match
    table_styles = [
        {"selector": "foo", "props": [("attr", f"val{i}")]} for i in range(500)
    ]
    table_styles.append({"selector": "foo", "props": [("attr", "last_value")]})
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 2.77μs -> 1.34μs (107% faster)


def test_large_number_of_styles_no_match():
    # Large number of styles, selector never matches
    table_styles = [
        {"selector": f"sel{i}", "props": [("attr", f"val{i}")]} for i in range(1000)
    ]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "notfound"
    )  # 25.8μs -> 23.4μs (10.2% faster)


def test_large_props_list():
    # Props list is large, only first item used
    props = [(f"attr{i}", f"val{i}") for i in range(1000)]
    table_styles = [{"selector": "foo", "props": props}]
    codeflash_output = _parse_latex_table_styles(
        table_styles, "foo"
    )  # 1.51μs -> 1.25μs (20.9% faster)


def test_large_styles_and_large_props():
    # Large table_styles and large props, selector matches last, props has many items
    table_styles = [
        {"selector": "foo", "props": [(f"attr{i}", f"val{i}") for i in range(500)]}
        for _ in range(999)
    ]
    table_styles.append(
        {"selector": "target", "props": [(f"attr{i}", f"val{i}") for i in range(1000)]}
    )
    codeflash_output = _parse_latex_table_styles(
        table_styles, "target"
    )  # 14.2μs -> 2.50μs (468% faster)


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

To edit these changes git checkout codeflash/optimize-_parse_latex_table_styles-mio81xta and push.