⚡️ Speed up function _parse_latex_css_conversion by 40%

[codeflash-ai]

📄 40% (0.40x) speedup for _parse_latex_css_conversion in pandas/io/formats/style_render.py

⏱️ Runtime : 13.2 milliseconds → 9.43 milliseconds (best of 46 runs)

📝 Explanation and details

The optimization achieves a 40% speedup by targeting the most expensive operations in CSS-to-LaTeX conversion, particularly for RGB color processing and loop inefficiencies.

Key Optimizations Applied

1. Pre-compiled Regex for RGB Parsing
The original code used multiple re.findall() calls with complex regex patterns for each RGB color. The optimized version compiles the regex once (RGB_RE) and uses a single findall() call to extract all RGB values at once, eliminating repeated regex compilation overhead.

2. Streamlined RGB Channel Processing
Instead of separate regex calls and repeated int/float branching for each RGB channel, the optimization extracts all values first, then processes them through a unified channel() function. This reduces the computational complexity from O(3n) regex operations to O(n) per RGB color.

3. Optimized Loop Structure
The original nested type checking (isinstance(value, str) and "--latex" in value) was restructured to check isinstance(value, str) once, then branch into string-specific logic. This avoids redundant type checks and string operations for non-string values.

4. Method Reference Caching
latex_styles.append is cached as a local variable to avoid attribute lookup overhead in tight loops, providing faster list mutations.

5. Eliminated Unnecessary Operations

• Removed redundant str() calls when the type is already known to be string
• Changed extend([single_item]) to direct append(single_item) calls
• Added fast-path for non-string values to skip string processing entirely

Performance Impact by Test Case

The optimization particularly excels with RGB/RGBA color processing (8-49% faster) and large-scale operations (25-49% faster), which aligns with the function being called from _parse_latex_cell_styles where it processes multiple CSS styles per cell in pandas styling operations. The regex optimization significantly benefits workloads with many RGB colors, while the streamlined control flow helps all test cases avoid unnecessary work.

Simple conversions show minor overhead due to regex compilation, but this is overwhelmed by gains in realistic workloads with mixed or repeated color processing.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 68 Passed
🌀 Generated Regression Tests	✅ 79 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_css_conversion	91.9μs	101μs	-9.46%⚠️
io/formats/style/test_to_latex.py::test_parse_latex_css_conversion_option	3.22μs	4.44μs	-27.5%⚠️

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

from typing import Union

# imports
from pandas.io.formats.style_render import _parse_latex_css_conversion

CSSPair = tuple[str, Union[str, float]]
CSSList = list[CSSPair]

# unit tests

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


def test_font_weight_basic():
    # Test bold conversion
    styles = [("font-weight", "bold")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 3.53μs -> 4.45μs (20.5% slower)

    # Test bolder conversion
    styles = [("font-weight", "bolder")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 1.57μs -> 1.93μs (18.8% slower)

    # Test non-bold value (should not convert)
    styles = [("font-weight", "normal")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 1.23μs -> 1.51μs (18.4% slower)


def test_font_style_basic():
    # Test italic conversion
    styles = [("font-style", "italic")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 3.20μs -> 3.93μs (18.6% slower)

    # Test oblique conversion
    styles = [("font-style", "oblique")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 1.71μs -> 2.17μs (21.2% slower)

    # Test normal font-style (should not convert)
    styles = [("font-style", "normal")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 1.21μs -> 1.58μs (23.3% slower)


def test_color_named_basic():
    # Test named color conversion
    styles = [("color", "red")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 3.93μs -> 5.05μs (22.2% slower)


def test_color_hex_basic():
    # Test 6-digit hex color conversion
    styles = [("color", "#ff23ee")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 4.51μs -> 5.64μs (20.0% slower)

    # Test 3-digit hex color conversion
    styles = [("color", "#f0e")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 3.30μs -> 3.90μs (15.4% slower)


def test_color_rgb_basic():
    # Test rgb conversion
    styles = [("color", "rgb(128, 255, 0)")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 13.6μs -> 12.5μs (8.91% faster)


def test_color_rgba_basic():
    # Test rgba conversion
    styles = [("color", "rgba(128, 255, 0, 0.5)")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 12.4μs -> 11.8μs (5.41% faster)


def test_background_color_basic():
    # Test background-color with named color
    styles = [("background-color", "blue")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 4.19μs -> 4.92μs (14.8% slower)

    # Test background-color with hex
    styles = [("background-color", "#abc")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 3.42μs -> 3.88μs (11.7% slower)


def test_multiple_styles_basic():
    # Test multiple styles in one call
    styles = [
        ("font-weight", "bold"),
        ("font-style", "italic"),
        ("color", "#00ff00"),
        ("background-color", "yellow"),
    ]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 7.76μs -> 8.04μs (3.50% slower)
    expected = [
        ("bfseries", ""),
        ("itshape", ""),
        ("color", "[HTML]{00FF00}"),
        ("cellcolor", "{yellow}--lwrap"),
    ]


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


def test_latex_tag_passthrough():
    # If a value contains '--latex', it should be passed through and not converted
    styles = [("font-weight", "bold--latex"), ("color", "red--latex")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 6.13μs -> 6.75μs (9.18% slower)


def test_strip_comments_and_whitespace():
    # Test value with comments and whitespace
    styles = [("color", "red /* --wrap */  ")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 5.60μs -> 6.36μs (12.0% slower)


def test_wrap_arguments():
    # Test all wrap arguments
    for wrap in ["--wrap", "--nowrap", "--lwrap", "--dwrap", "--rwrap"]:
        styles = [("font-weight", f"bold {wrap}")]
        codeflash_output = _parse_latex_css_conversion(styles)
        result = codeflash_output  # 10.9μs -> 13.3μs (17.8% slower)


def test_rgb_percent_values():
    # Test rgb with percent values
    styles = [("color", "rgb(50%, 100%, 0%)")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 14.7μs -> 13.5μs (9.39% faster)


def test_rgba_percent_values():
    # Test rgba with percent values
    styles = [("color", "rgba(50%, 100%, 0%, 0.5)")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 12.9μs -> 12.4μs (4.73% faster)


def test_non_convertible_attribute():
    # Attribute not in CONVERTED_ATTRIBUTES should not be converted
    styles = [("border", "1px solid red")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 1.92μs -> 3.12μs (38.5% slower)


def test_empty_input():
    # Empty input should return empty list
    styles = []
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 1.66μs -> 2.62μs (36.9% slower)


def test_non_string_value():
    # Non-string value for font-weight
    styles = [("font-weight", 700)]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 3.37μs -> 3.70μs (9.00% slower)


def test_invalid_color_format():
    # Invalid color format should be treated as string
    styles = [("color", "notacolor")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 4.37μs -> 5.26μs (16.9% slower)


def test_case_insensitive_hex():
    # Case insensitive hex code
    styles = [("color", "#aBcDeF")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 4.42μs -> 5.41μs (18.3% slower)


def test_background_color_short_hex():
    # background-color with short hex
    styles = [("background-color", "#1a2")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 5.18μs -> 6.16μs (16.0% slower)


def test_background_color_rgb():
    # background-color with rgb
    styles = [("background-color", "rgb(255, 0, 128)")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 14.0μs -> 12.8μs (9.01% faster)


def test_background_color_rgba():
    # background-color with rgba
    styles = [("background-color", "rgba(0, 128, 255, 0.3)")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 12.7μs -> 12.3μs (3.47% faster)


def test_background_color_percent_rgb():
    # background-color with percent rgb
    styles = [("background-color", "rgb(100%, 50%, 0%)")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 12.9μs -> 12.4μs (3.89% faster)


def test_background_color_percent_rgba():
    # background-color with percent rgba
    styles = [("background-color", "rgba(100%, 50%, 0%, 0.3)")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 13.0μs -> 12.3μs (6.16% faster)


def test_multiple_wrap_args():
    # If multiple wrap args, only the first should be used
    styles = [("font-weight", "bold --wrap --nowrap")]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 4.09μs -> 4.98μs (17.9% slower)


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


def test_large_scale_many_styles():
    # Test with many styles (up to 1000)
    styles = []
    for i in range(500):
        styles.append(("font-weight", "bold"))
        styles.append(("color", f"rgb({i % 256}, {(i * 2) % 256}, {(i * 3) % 256})"))
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 1.99ms -> 1.37ms (45.5% faster)
    # Check a sample rgb conversion
    sample_rgb = f"rgb({123 % 256}, {(123 * 2) % 256}, {(123 * 3) % 256})"
    codeflash_output = _parse_latex_css_conversion([("color", sample_rgb)])
    sample_result = codeflash_output  # 5.80μs -> 5.58μs (3.96% faster)


def test_large_scale_mixed_styles():
    # Mix many types of styles
    styles = []
    for i in range(250):
        styles.append(("font-weight", "bold"))
        styles.append(("font-style", "italic"))
        styles.append(("color", "#%02x%02x%02x" % (i, i, i)))
        styles.append(("background-color", "rgb(100%, 0%, 0%)"))
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 1.29ms -> 913μs (41.5% faster)


def test_large_scale_passthrough_latex():
    # Large scale with --latex passthrough
    styles = [("font-weight", "bold--latex")] * 500
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 208μs -> 167μs (25.0% faster)


def test_large_scale_no_convertible():
    # Large scale with no convertible attributes
    styles = [("border", "1px solid red")] * 1000
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 44.8μs -> 50.1μs (10.4% slower)


def test_large_scale_empty():
    # Large scale with empty input
    styles = []
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 1.64μs -> 2.78μs (41.2% slower)


# 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

from typing import Union

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

CSSPair = tuple[str, Union[str, float]]
CSSList = list[CSSPair]

# unit tests

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


def test_font_weight_basic():
    # Test basic font-weight conversion
    codeflash_output = _parse_latex_css_conversion(
        [("font-weight", "bold")]
    )  # 3.30μs -> 4.11μs (19.8% slower)
    codeflash_output = _parse_latex_css_conversion(
        [("font-weight", "bolder")]
    )  # 1.73μs -> 2.14μs (19.0% slower)
    # Should not convert 'normal'
    codeflash_output = _parse_latex_css_conversion(
        [("font-weight", "normal")]
    )  # 1.22μs -> 1.58μs (23.2% slower)


def test_font_style_basic():
    # Test basic font-style conversion
    codeflash_output = _parse_latex_css_conversion(
        [("font-style", "italic")]
    )  # 2.99μs -> 3.75μs (20.3% slower)
    codeflash_output = _parse_latex_css_conversion(
        [("font-style", "oblique")]
    )  # 1.84μs -> 2.14μs (14.3% slower)
    # Should not convert 'normal'
    codeflash_output = _parse_latex_css_conversion(
        [("font-style", "normal")]
    )  # 1.24μs -> 1.59μs (22.2% slower)


def test_color_string_basic():
    # Named color conversion
    codeflash_output = _parse_latex_css_conversion(
        [("color", "red")]
    )  # 3.98μs -> 4.67μs (14.9% slower)
    codeflash_output = _parse_latex_css_conversion(
        [("color", "blue")]
    )  # 2.17μs -> 2.67μs (18.5% slower)
    codeflash_output = _parse_latex_css_conversion(
        [("background-color", "green")]
    )  # 1.74μs -> 2.05μs (15.1% slower)


def test_color_hex_basic():
    # 6-digit hex code
    codeflash_output = _parse_latex_css_conversion(
        [("color", "#ff23ee")]
    )  # 4.37μs -> 5.19μs (15.8% slower)
    # 3-digit hex code
    codeflash_output = _parse_latex_css_conversion(
        [("color", "#f0e")]
    )  # 2.95μs -> 3.75μs (21.4% slower)


def test_color_rgb_basic():
    # rgb and rgba conversion
    codeflash_output = _parse_latex_css_conversion(
        [("color", "rgb(128, 255, 0)")]
    )  # 13.3μs -> 12.2μs (9.22% faster)
    codeflash_output = _parse_latex_css_conversion(
        [("color", "rgba(128, 255, 0, 0.5)")]
    )  # 7.03μs -> 6.76μs (3.90% faster)


def test_color_rgb_percent():
    # rgb with percent values
    codeflash_output = _parse_latex_css_conversion(
        [("color", "rgb(50%, 100%, 0%)")]
    )  # 12.4μs -> 11.4μs (8.03% faster)
    codeflash_output = _parse_latex_css_conversion(
        [("color", "rgba(50%, 100%, 0%, 0.5)")]
    )  # 7.16μs -> 6.92μs (3.48% faster)


def test_background_color_hex_and_named():
    # background-color with hex and named color
    codeflash_output = _parse_latex_css_conversion(
        [("background-color", "#abcdef")]
    )  # 4.42μs -> 5.18μs (14.6% slower)
    codeflash_output = _parse_latex_css_conversion(
        [("background-color", "yellow")]
    )  # 2.45μs -> 3.02μs (18.6% slower)


def test_multiple_styles_basic():
    # Multiple styles in one call
    styles = [
        ("font-weight", "bold"),
        ("font-style", "italic"),
        ("color", "red"),
        ("background-color", "#123456"),
    ]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 7.13μs -> 7.67μs (7.06% slower)


def test_ignore_non_convertible():
    # Should ignore unknown attributes
    codeflash_output = _parse_latex_css_conversion(
        [("border", "1px solid black")]
    )  # 1.97μs -> 3.08μs (36.0% slower)


def test_latex_flag_passthrough():
    # Should pass through --latex tagged values unchanged except for removing --latex
    codeflash_output = _parse_latex_css_conversion(
        [("color", "red--latex")]
    )  # 4.83μs -> 5.63μs (14.3% slower)
    codeflash_output = _parse_latex_css_conversion(
        [("font-weight", "bold--latex")]
    )  # 2.60μs -> 2.82μs (7.83% slower)


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


def test_empty_input():
    # Empty input should return empty list
    codeflash_output = _parse_latex_css_conversion(
        []
    )  # 1.50μs -> 2.56μs (41.2% slower)


def test_unknown_attribute():
    # Unknown attribute should be ignored
    codeflash_output = _parse_latex_css_conversion(
        [("unknown", "value")]
    )  # 1.84μs -> 3.00μs (38.7% slower)


def test_strip_comments_and_whitespace():
    # Value with comments and whitespace should be stripped
    codeflash_output = _parse_latex_css_conversion(
        [("color", "red /* --wrap */  ")]
    )  # 6.34μs -> 7.29μs (13.1% slower)
    codeflash_output = _parse_latex_css_conversion(
        [("font-weight", "bold /* --wrap */ ")]
    )  # 2.82μs -> 3.46μs (18.6% slower)


def test_multiple_flags():
    # Multiple flags, should pick the first
    codeflash_output = _parse_latex_css_conversion(
        [("color", "red--wrap--nowrap")]
    )  # 5.08μs -> 5.88μs (13.6% slower)


def test_unusual_rgb_format():
    # Extra spaces and missing values
    codeflash_output = _parse_latex_css_conversion(
        [("color", "rgb( 128 , 255 , 0 )")]
    )  # 13.8μs -> 12.8μs (8.27% faster)
    # Missing closing parenthesis (should raise error)
    with pytest.raises(IndexError):
        _parse_latex_css_conversion(
            [("color", "rgb(128,255,0")]
        )  # 6.20μs -> 5.38μs (15.3% faster)


def test_short_hex_case_insensitive():
    # Lowercase and uppercase hex code
    codeflash_output = _parse_latex_css_conversion(
        [("color", "#abc")]
    )  # 5.45μs -> 6.25μs (12.9% slower)
    codeflash_output = _parse_latex_css_conversion(
        [("color", "#ABC")]
    )  # 2.36μs -> 3.02μs (22.1% slower)


def test_flags_on_background_color():
    # Flags on background-color
    codeflash_output = _parse_latex_css_conversion(
        [("background-color", "red--wrap")]
    )  # 5.09μs -> 5.86μs (13.2% slower)
    codeflash_output = _parse_latex_css_conversion(
        [("background-color", "#123456--nowrap")]
    )  # 3.38μs -> 3.89μs (13.1% slower)


def test_flag_in_middle_of_value():
    # Flag in middle, should still be stripped
    codeflash_output = _parse_latex_css_conversion(
        [("color", "red--wrapblue")]
    )  # 5.80μs -> 6.90μs (15.9% slower)


def test_background_color_with_rgb_percent():
    # background-color with rgb percent
    codeflash_output = _parse_latex_css_conversion(
        [("background-color", "rgb(50%, 100%, 0%)")]
    )  # 15.2μs -> 14.0μs (8.90% faster)


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


def test_large_number_of_styles():
    # Large number of styles, all convertible
    styles = [
        ("color", f"rgb({i % 256}, {(i * 2) % 256}, {(i * 3) % 256})")
        for i in range(1000)
    ]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 3.63ms -> 2.43ms (49.4% faster)
    for i, (cmd, val) in enumerate(result):
        # Check that values are in expected range
        vals = val[6 : val.index("}")]  # e.g. "0.000, 1.000, 0.000"
        floats = [float(x.strip()) for x in vals.split(",")]
        for f in floats:
            pass


def test_large_mixed_styles():
    # Large number of mixed styles
    styles = []
    for i in range(250):
        styles.append(("font-weight", "bold"))
        styles.append(("font-style", "italic"))
        styles.append(("color", f"#a{i % 10}b{i % 10}c{i % 10}"))
        styles.append(("background-color", f"rgb({i % 100}%, {i % 100}%, {i % 100}%)"))
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 1.34ms -> 932μs (43.4% faster)
    # Check that all commands are valid
    for cmd, val in result:
        pass


def test_large_number_of_non_convertible():
    # Large number of unconvertible attributes
    styles = [("border", "1px solid black") for _ in range(1000)]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 45.0μs -> 50.9μs (11.6% slower)


def test_large_number_with_flags():
    # Large number with flags
    styles = [("color", "red--wrap") for _ in range(1000)]
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 627μs -> 595μs (5.40% faster)


def test_performance_large_scale():
    # Large scale performance (should not take too long)
    import time

    styles = [
        ("color", f"rgb({i % 256}, {(i * 2) % 256}, {(i * 3) % 256})")
        for i in range(999)
    ]
    start = time.time()
    codeflash_output = _parse_latex_css_conversion(styles)
    result = codeflash_output  # 3.56ms -> 2.42ms (47.2% faster)
    elapsed = time.time() - start


# 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_css_conversion-mio99pk4 and push.