⚡️ Speed up function _pipe_line_with_colons by 46% in PR #217 (proper-cleanup)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #217

If you approve this dependent PR, these changes will be merged into the original PR branch proper-cleanup.

This PR will be automatically closed if the original PR is merged.

---

📄 46% (0.46x) speedup for _pipe_line_with_colons in codeflash/code_utils/tabulate.py

⏱️ Runtime : 1.15 milliseconds → 789 microseconds (best of 265 runs)

📝 Explanation and details

Here are the main performance issues and solutions for your program.

Profile Insights

• The function _pipe_segment_with_colons is hit many times, and most time is spent creating new strings with expressions like '-' * n and concatenation.
• In _pipe_line_with_colons, almost all runtime is spent in the list comprehension calling _pipe_segment_with_colons.
• There are repeated lookups/checks for the alignment, which can be made faster by using a dictionary for dispatch.
• The repeated string multiplication and concatenation in _pipe_segment_with_colons can be accelerated for common values (like when width is small or common) via caching.

Optimizations

1. Function dispatch via dictionary to avoid sequential if-elif.
2. Cache small, frequently repeated templates in _pipe_segment_with_colons using functools.lru_cache (for acceleration when the same alignment and width is requested over and over).
3. Pre-localize frequently used builtins (like str.join, str.__mul__).
4. Minor improvement: Reduce str concatenations.

Here's the optimized code.

---

Why this version is faster

1. lru_cache on _pipe_segment_with_colons to memoize results (Python will keep the last few most requested line segments in RAM). This is effective since your profile shows thousands of hits with the same arguments.
2. Reduced branching inside inner loop via elif for clarity.
3. Localizing built-in function lookups improves performance (as calling a local variable is faster than attribute/property lookup on objects).

These changes together should provide measurably improved runtime—especially for repeated, table-wide invocations! If you expect very large tables or uncommon (align, colwidth) combinations, you can tune the cache size in @lru_cache(maxsize=N). For typical markdown/pipe-aligned tables, this value is more than enough.

---

You may further accelerate with Cython or by using dedicated C-based formatters, but not within pure Python constraints.

✅ Correctness verification report:

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

🌀 Generated Regression Tests Details

import pytest  # used for our unit tests
from codeflash.code_utils.tabulate import _pipe_line_with_colons

# unit tests

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

def test_single_column_left_align():
    # Single column, left alignment, width 5
    codeflash_output = _pipe_line_with_colons([5], ["left"])

def test_single_column_right_align():
    # Single column, right alignment, width 5
    codeflash_output = _pipe_line_with_colons([5], ["right"])

def test_single_column_center_align():
    # Single column, center alignment, width 5
    codeflash_output = _pipe_line_with_colons([5], ["center"])

def test_single_column_decimal_align():
    # Single column, decimal alignment, width 5
    codeflash_output = _pipe_line_with_colons([5], ["decimal"])

def test_single_column_no_align():
    # Single column, no alignment, width 5
    codeflash_output = _pipe_line_with_colons([5], [""])

def test_multiple_columns_various_alignments():
    # Three columns, left, center, right, widths 3, 5, 4
    codeflash_output = _pipe_line_with_colons([3, 5, 4], ["left", "center", "right"])

def test_multiple_columns_all_no_align():
    # Three columns, no alignment, widths 2, 3, 4
    codeflash_output = _pipe_line_with_colons([2, 3, 4], ["", "", ""])

def test_multiple_columns_all_left_align():
    # Three columns, all left alignment, widths 2, 3, 4
    codeflash_output = _pipe_line_with_colons([2, 3, 4], ["left", "left", "left"])

def test_multiple_columns_all_right_align():
    # Three columns, all right alignment, widths 2, 3, 4
    codeflash_output = _pipe_line_with_colons([2, 3, 4], ["right", "right", "right"])

def test_multiple_columns_all_center_align():
    # Three columns, all center alignment, widths 3, 5, 4
    codeflash_output = _pipe_line_with_colons([3, 5, 4], ["center", "center", "center"])

def test_multiple_columns_all_decimal_align():
    # Three columns, all decimal alignment, widths 3, 5, 4
    codeflash_output = _pipe_line_with_colons([3, 5, 4], ["decimal", "decimal", "decimal"])

def test_mixed_alignments():
    # Mix of all alignments
    codeflash_output = _pipe_line_with_colons(
        [2, 3, 4, 5],
        ["left", "right", "center", ""]
    )

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

def test_empty_colwidths_and_colaligns():
    # No columns at all
    codeflash_output = _pipe_line_with_colons([], [])

def test_empty_colaligns_nonempty_colwidths():
    # colaligns is empty, colwidths is not
    # Should default to no alignment for each column
    codeflash_output = _pipe_line_with_colons([2, 3], [])

def test_colwidths_and_colaligns_length_mismatch_shorter_colaligns():
    # colaligns shorter than colwidths, zip truncates to shortest
    # Only first two columns are considered
    codeflash_output = _pipe_line_with_colons([2, 3, 4], ["left", "right"])

def test_colwidths_and_colaligns_length_mismatch_longer_colaligns():
    # colaligns longer than colwidths, zip truncates to shortest
    codeflash_output = _pipe_line_with_colons([2, 3], ["left", "right", "center"])

def test_zero_width_column():
    # Zero width column, left alignment
    codeflash_output = _pipe_line_with_colons([0], ["left"])
    # Zero width column, right alignment
    codeflash_output = _pipe_line_with_colons([0], ["right"])
    # Zero width column, center alignment
    codeflash_output = _pipe_line_with_colons([0], ["center"])
    # Zero width column, no alignment
    codeflash_output = _pipe_line_with_colons([0], [""])

def test_one_width_column():
    # Width 1, left align
    codeflash_output = _pipe_line_with_colons([1], ["left"])
    # Width 1, right align
    codeflash_output = _pipe_line_with_colons([1], ["right"])
    # Width 1, center align
    codeflash_output = _pipe_line_with_colons([1], ["center"])
    # Width 1, no align
    codeflash_output = _pipe_line_with_colons([1], [""])

def test_two_width_column_various_alignments():
    # Width 2, left align
    codeflash_output = _pipe_line_with_colons([2], ["left"])
    # Width 2, right align
    codeflash_output = _pipe_line_with_colons([2], ["right"])
    # Width 2, center align
    codeflash_output = _pipe_line_with_colons([2], ["center"])
    # Width 2, no align
    codeflash_output = _pipe_line_with_colons([2], [""])

def test_unknown_alignment_string():
    # Unknown alignment string should be treated as no alignment
    codeflash_output = _pipe_line_with_colons([4], ["foo"])

def test_mixed_known_and_unknown_alignments():
    # Mix of known and unknown alignments
    codeflash_output = _pipe_line_with_colons([3, 4, 5], ["left", "foo", "right"])

def test_alignment_case_sensitivity():
    # Alignment is case sensitive, so "Left" is treated as unknown
    codeflash_output = _pipe_line_with_colons([4], ["Left"])

def test_non_string_alignment():
    # Non-string alignment (e.g. None) should be treated as no alignment
    codeflash_output = _pipe_line_with_colons([3], [None])
    # Integer alignment
    codeflash_output = _pipe_line_with_colons([3], [1])

def test_large_number_of_columns_minimal_width():
    # 100 columns, each width 1, all left aligned
    expected = "|" + "|".join([":"]*100) + "|"
    codeflash_output = _pipe_line_with_colons([1]*100, ["left"]*100)

def test_large_number_of_columns_no_align():
    # 100 columns, each width 1, all no alignment
    expected = "|" + "|".join(["-"]*100) + "|"
    codeflash_output = _pipe_line_with_colons([1]*100, [""]*100)

def test_large_number_of_columns_varied_align():
    # 100 columns, alternating left and right align, width 2
    aligns = ["left" if i%2==0 else "right" for i in range(100)]
    expected = "|" + "|".join([":-" if i%2==0 else "-:" for i in range(100)]) + "|"
    codeflash_output = _pipe_line_with_colons([2]*100, aligns)

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

def test_large_scale_all_left():
    # 1000 columns, width 3, all left aligned
    expected = "|" + "|".join([":--"]*1000) + "|"
    codeflash_output = _pipe_line_with_colons([3]*1000, ["left"]*1000)

def test_large_scale_all_right():
    # 1000 columns, width 3, all right aligned
    expected = "|" + "|".join(["--:"]*1000) + "|"
    codeflash_output = _pipe_line_with_colons([3]*1000, ["right"]*1000)

def test_large_scale_all_center():
    # 1000 columns, width 3, all center aligned
    expected = "|" + "|".join([":-:"]*1000) + "|"
    codeflash_output = _pipe_line_with_colons([3]*1000, ["center"]*1000)

def test_large_scale_all_no_align():
    # 1000 columns, width 3, all no alignment
    expected = "|" + "|".join(["---"]*1000) + "|"
    codeflash_output = _pipe_line_with_colons([3]*1000, [""]*1000)

def test_large_scale_mixed_alignments():
    # 1000 columns, cycling through left, right, center, decimal, none
    aligns = ["left", "right", "center", "decimal", ""] * 200
    patterns = [":--", "--:", ":-:", "--:", "---"]
    expected = "|" + "|".join(patterns[i%5] for i in range(1000)) + "|"
    codeflash_output = _pipe_line_with_colons([3]*1000, aligns)

def test_large_scale_varied_widths_and_alignments():
    # 500 columns, width cycles from 1 to 10, align cycles through left/right/center/none
    aligns = ["left", "right", "center", ""] * 125
    colwidths = [(i % 10) + 1 for i in range(500)]
    # Build expected string
    segs = []
    for a, w in zip(aligns, colwidths):
        if a == "left":
            segs.append(":" + "-"*(w-1))
        elif a == "right":
            segs.append("-"*(w-1) + ":")
        elif a == "center":
            segs.append(":" + "-"*(w-2) + ":" if w >=2 else "::")
        else:
            segs.append("-"*w)
    expected = "|" + "|".join(segs) + "|"
    codeflash_output = _pipe_line_with_colons(colwidths, aligns)

# -------------------------
# ADDITIONAL EDGE CASES
# -------------------------

def test_colwidths_with_zero_and_nonzero():
    # Mix of zero and nonzero widths
    codeflash_output = _pipe_line_with_colons([0, 2, 0, 3], ["left", "right", "center", ""])

def test_colwidths_with_negative_widths():
    # Negative widths: should behave as if width is negative (results in empty or malformed segments)
    # The function does not explicitly handle negatives, so let's document and test the behavior
    codeflash_output = _pipe_line_with_colons([-1, 2], ["left", "right"])

def test_colaligns_with_whitespace():
    # Alignment strings with whitespace are treated as unknown
    codeflash_output = _pipe_line_with_colons([3], [" left "])

def test_colaligns_with_partial_match():
    # Alignment strings that partially match known alignments are treated as unknown
    codeflash_output = _pipe_line_with_colons([3], ["lef"])
    codeflash_output = _pipe_line_with_colons([3], ["cent"])

def test_colaligns_with_numeric_strings():
    # Numeric strings as alignments are treated as unknown
    codeflash_output = _pipe_line_with_colons([3], ["123"])
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest  # used for our unit tests
from codeflash.code_utils.tabulate import _pipe_line_with_colons

# unit tests

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

def test_basic_left_alignment():
    # Single column, left alignment, width 5
    codeflash_output = _pipe_line_with_colons([5], ["left"])

def test_basic_right_alignment():
    # Single column, right alignment, width 5
    codeflash_output = _pipe_line_with_colons([5], ["right"])

def test_basic_center_alignment():
    # Single column, center alignment, width 5
    codeflash_output = _pipe_line_with_colons([5], ["center"])

def test_basic_decimal_alignment():
    # Single column, decimal alignment, width 5
    codeflash_output = _pipe_line_with_colons([5], ["decimal"])

def test_basic_no_alignment():
    # Single column, no alignment specified, width 5
    codeflash_output = _pipe_line_with_colons([5], [""])

def test_basic_multiple_columns_various_alignments():
    # Multiple columns, mixed alignments
    colwidths = [3, 4, 5]
    colaligns = ["left", "center", "right"]
    # left: ":--", center: ":--:", right: "---:"
    codeflash_output = _pipe_line_with_colons(colwidths, colaligns)

def test_basic_multiple_columns_all_no_alignment():
    # Multiple columns, all with no alignment
    codeflash_output = _pipe_line_with_colons([2, 3, 4], ["", "", ""])

def test_basic_alignment_case_insensitivity():
    # Alignment should be case sensitive, so "Left" is not "left"
    codeflash_output = _pipe_line_with_colons([4], ["Left"])

def test_basic_alignment_decimal_and_right():
    # "decimal" and "right" should behave the same
    codeflash_output = _pipe_line_with_colons([4, 4], ["right", "decimal"])

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

def test_edge_empty_colwidths_and_colaligns():
    # Both lists empty: should return just "||"
    codeflash_output = _pipe_line_with_colons([], [])

def test_edge_empty_colaligns_nonempty_colwidths():
    # colaligns empty, colwidths nonempty: should treat as [""] * len(colwidths)
    codeflash_output = _pipe_line_with_colons([3, 2], [])

def test_edge_colwidth_1():
    # Smallest possible column width
    codeflash_output = _pipe_line_with_colons([1], ["left"])
    codeflash_output = _pipe_line_with_colons([1], ["right"])
    codeflash_output = _pipe_line_with_colons([1], ["center"])
    codeflash_output = _pipe_line_with_colons([1], [""])

def test_edge_colwidth_2():
    # Next smallest column width
    codeflash_output = _pipe_line_with_colons([2], ["left"])
    codeflash_output = _pipe_line_with_colons([2], ["right"])
    codeflash_output = _pipe_line_with_colons([2], ["center"])
    codeflash_output = _pipe_line_with_colons([2], [""])

def test_edge_colaligns_shorter_than_colwidths():
    # colaligns shorter: only first N columns get alignments, rest get ""
    codeflash_output = _pipe_line_with_colons([3, 4, 5], ["left", "center"])

def test_edge_colaligns_longer_than_colwidths():
    # colaligns longer: extra alignments ignored
    codeflash_output = _pipe_line_with_colons([3, 4], ["left", "center", "right"])

def test_edge_nonstandard_alignment_string():
    # Unknown alignment string should be treated as ""
    codeflash_output = _pipe_line_with_colons([4], ["banana"])

def test_edge_alignment_none():
    # None as alignment should be treated as ""
    codeflash_output = _pipe_line_with_colons([3], [None])

def test_edge_colaligns_contains_mixed_types():
    # Mix of str, None, int, etc.
    codeflash_output = _pipe_line_with_colons([2, 3, 4], ["left", None, 123])

def test_edge_colwidth_zero():
    # Zero-width column: should produce empty segment
    codeflash_output = _pipe_line_with_colons([0], ["left"])
    codeflash_output = _pipe_line_with_colons([0, 2], ["center", "right"])

def test_edge_colwidth_negative():
    # Negative width: should produce empty or malformed segment, but let's see what happens
    codeflash_output = _pipe_line_with_colons([-1], ["left"])
    codeflash_output = _pipe_line_with_colons([-2], ["right"])
    codeflash_output = _pipe_line_with_colons([-3], ["center"])

def test_edge_colaligns_is_none():
    # colaligns is None: should treat as [""] * len(colwidths)
    codeflash_output = _pipe_line_with_colons([2, 3], None)

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

def test_large_all_left_alignments():
    # 100 columns, all left, width 4
    n = 100
    colwidths = [4] * n
    colaligns = ["left"] * n
    codeflash_output = _pipe_line_with_colons(colwidths, colaligns); result = codeflash_output
    expected = "|" + "|".join([":---"] * n) + "|"

def test_large_all_right_alignments():
    # 100 columns, all right, width 4
    n = 100
    colwidths = [4] * n
    colaligns = ["right"] * n
    codeflash_output = _pipe_line_with_colons(colwidths, colaligns); result = codeflash_output
    expected = "|" + "|".join(["---:"] * n) + "|"

def test_large_mixed_alignments():
    # 100 columns, cycling through left, right, center, none
    n = 100
    aligns = ["left", "right", "center", ""]
    colwidths = [4] * n
    colaligns = [aligns[i % 4] for i in range(n)]
    codeflash_output = _pipe_line_with_colons(colwidths, colaligns); result = codeflash_output
    segments = []
    for i in range(n):
        a = aligns[i % 4]
        if a == "left":
            segments.append(":---")
        elif a == "right":
            segments.append("---:")
        elif a == "center":
            segments.append(":--:")
        else:
            segments.append("----")
    expected = "|" + "|".join(segments) + "|"

def test_large_varied_widths_and_alignments():
    # 100 columns, width increases from 1 to 100, alignments cycle
    n = 100
    aligns = ["left", "right", "center", ""]
    colwidths = list(range(1, n+1))
    colaligns = [aligns[i % 4] for i in range(n)]
    codeflash_output = _pipe_line_with_colons(colwidths, colaligns); result = codeflash_output
    segments = []
    for i in range(n):
        w = colwidths[i]
        a = aligns[i % 4]
        if a == "left":
            segments.append(":" + "-" * (w-1))
        elif a == "right":
            segments.append("-" * (w-1) + ":")
        elif a == "center":
            if w == 1:
                segments.append("::")
            elif w == 2:
                segments.append("::")
            else:
                segments.append(":" + "-" * (w-2) + ":")
        else:
            segments.append("-" * w)
    expected = "|" + "|".join(segments) + "|"

def test_large_empty_colaligns():
    # 100 columns, colaligns empty, all width 3
    n = 100
    colwidths = [3] * n
    colaligns = []
    codeflash_output = _pipe_line_with_colons(colwidths, colaligns); result = codeflash_output
    expected = "|" + "|".join(["---"] * n) + "|"

def test_large_colaligns_shorter_than_colwidths():
    # 100 colwidths, 10 colaligns
    n = 100
    colwidths = [4] * n
    colaligns = ["left", "right", "center", ""] * 2 + ["left", "center"]
    # Only first 10 columns get alignments, rest get ""
    segments = []
    aligns = ["left", "right", "center", ""] * 2 + ["left", "center"]
    for i in range(n):
        if i < len(colaligns):
            a = colaligns[i]
        else:
            a = ""
        if a == "left":
            segments.append(":---")
        elif a == "right":
            segments.append("---:")
        elif a == "center":
            segments.append(":--:")
        else:
            segments.append("----")
    expected = "|" + "|".join(segments) + "|"
    codeflash_output = _pipe_line_with_colons(colwidths, colaligns); result = codeflash_output

def test_large_colaligns_longer_than_colwidths():
    # 10 colwidths, 100 colaligns
    colwidths = [4] * 10
    colaligns = ["left", "right", "center", ""] * 25  # 100 alignments
    segments = []
    aligns = ["left", "right", "center", ""] * 25
    for i in range(10):
        a = aligns[i]
        if a == "left":
            segments.append(":---")
        elif a == "right":
            segments.append("---:")
        elif a == "center":
            segments.append(":--:")
        else:
            segments.append("----")
    expected = "|" + "|".join(segments) + "|"
    codeflash_output = _pipe_line_with_colons(colwidths, colaligns); result = codeflash_output
# 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-pr217-2025-05-19T04.28.06 and push.