⚡️ Speed up function _pipe_segment_with_colons by 11% 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.

---

📄 11% (0.11x) speedup for _pipe_segment_with_colons in codeflash/code_utils/tabulate.py

⏱️ Runtime : 118 microseconds → 106 microseconds (best of 325 runs)

📝 Explanation and details

Here is a faster rewrite of your function. The main optimizations.

• Replace {} set literal with tuple () for membership check, as a tuple is faster for small constant sets and avoids dynamic hashing.

• Use string multiplication only as needed.

• Use guarded string concatenation to minimize interpretation overhead.

• Match aligns in order of likelihood (generally "left" or "right" is more common than "center" or "decimal", adjust if your usage is different).

• Consolidate conditions to reduce branching where possible.

• This version uses direct comparison for the common cases and avoids the overhead of set/tuple lookup.

• The order of conditions can be adjusted depending on which alignment is most frequent in your workload for optimal branch prediction.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 318 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_segment_with_colons

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

def test_left_alignment_basic():
    # Left alignment, colwidth=5: should start with colon, then 4 dashes
    codeflash_output = _pipe_segment_with_colons("left", 5)

def test_right_alignment_basic():
    # Right alignment, colwidth=5: should be 4 dashes, then colon
    codeflash_output = _pipe_segment_with_colons("right", 5)

def test_center_alignment_basic():
    # Center alignment, colwidth=5: colon, 3 dashes, colon
    codeflash_output = _pipe_segment_with_colons("center", 5)

def test_decimal_alignment_basic():
    # Decimal alignment, colwidth=5: same as right
    codeflash_output = _pipe_segment_with_colons("decimal", 5)

def test_default_alignment_basic():
    # Unknown alignment, colwidth=5: just 5 dashes
    codeflash_output = _pipe_segment_with_colons("random", 5)

def test_left_alignment_colwidth_1():
    # Left alignment, colwidth=1: should be just colon
    codeflash_output = _pipe_segment_with_colons("left", 1)

def test_right_alignment_colwidth_1():
    # Right alignment, colwidth=1: should be just colon
    codeflash_output = _pipe_segment_with_colons("right", 1)

def test_center_alignment_colwidth_2():
    # Center alignment, colwidth=2: should be "::"
    codeflash_output = _pipe_segment_with_colons("center", 2)

def test_center_alignment_colwidth_3():
    # Center alignment, colwidth=3: should be ":-:"
    codeflash_output = _pipe_segment_with_colons("center", 3)

def test_default_alignment_colwidth_1():
    # Unknown alignment, colwidth=1: should be "-"
    codeflash_output = _pipe_segment_with_colons("foo", 1)

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

def test_zero_colwidth():
    # colwidth=0: should return empty string for all alignments
    for align in ["left", "right", "center", "decimal", "random"]:
        codeflash_output = _pipe_segment_with_colons(align, 0)

def test_negative_colwidth():
    # Negative colwidth: should return empty string for all alignments (since "-" * negative = "")
    for align in ["left", "right", "center", "decimal", "random"]:
        codeflash_output = _pipe_segment_with_colons(align, -5)

def test_unusual_alignment_strings():
    # Alignment string is empty
    codeflash_output = _pipe_segment_with_colons("", 5)
    # Alignment string is None (should raise TypeError)
    with pytest.raises(TypeError):
        _pipe_segment_with_colons(None, 5)
    # Alignment string is a number (should raise AttributeError or TypeError)
    with pytest.raises(TypeError):
        _pipe_segment_with_colons(123, 5)

def test_colwidth_non_integer():
    # colwidth is a float: should raise TypeError
    with pytest.raises(TypeError):
        _pipe_segment_with_colons("left", 3.5)
    # colwidth is a string: should raise TypeError
    with pytest.raises(TypeError):
        _pipe_segment_with_colons("left", "5")

def test_case_sensitivity():
    # Should be case-sensitive: "Left" is not "left"
    codeflash_output = _pipe_segment_with_colons("Left", 5)
    codeflash_output = _pipe_segment_with_colons("RIGHT", 5)
    codeflash_output = _pipe_segment_with_colons("Center", 5)

def test_colwidth_2_left_right_decimal():
    # colwidth=2, left: ":-"
    codeflash_output = _pipe_segment_with_colons("left", 2)
    # colwidth=2, right: "-:"
    codeflash_output = _pipe_segment_with_colons("right", 2)
    # colwidth=2, decimal: "-:"
    codeflash_output = _pipe_segment_with_colons("decimal", 2)

def test_colwidth_1_center():
    # colwidth=1, center: should be "::" *but* (w-2)==-1, so ":" + "" + ":" == "::"
    codeflash_output = _pipe_segment_with_colons("center", 1)

def test_colwidth_0_center():
    # colwidth=0, center: ":" + "-"*-2 + ":" == "::"
    codeflash_output = _pipe_segment_with_colons("center", 0)

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

def test_large_colwidth_left():
    # Large colwidth (e.g. 1000), left alignment: should be ":" + 999 dashes
    codeflash_output = _pipe_segment_with_colons("left", 1000); result = codeflash_output

def test_large_colwidth_right():
    # Large colwidth (e.g. 1000), right alignment: should be 999 dashes + ":"
    codeflash_output = _pipe_segment_with_colons("right", 1000); result = codeflash_output

def test_large_colwidth_center():
    # Large colwidth (e.g. 1000), center alignment: should be ":" + 998 dashes + ":"
    codeflash_output = _pipe_segment_with_colons("center", 1000); result = codeflash_output

def test_large_colwidth_decimal():
    # Large colwidth (e.g. 1000), decimal alignment: should be 999 dashes + ":"
    codeflash_output = _pipe_segment_with_colons("decimal", 1000); result = codeflash_output

def test_large_colwidth_default():
    # Large colwidth (e.g. 1000), unknown alignment: just 1000 dashes
    codeflash_output = _pipe_segment_with_colons("foobar", 1000); result = codeflash_output

def test_all_alignments_bulk():
    # Test all alignments with a range of colwidths from 1 to 20
    alignments = ["left", "right", "center", "decimal", "foo"]
    for align in alignments:
        for w in range(1, 21):
            codeflash_output = _pipe_segment_with_colons(align, w); seg = codeflash_output
            # For known alignments, check start/end colon positions
            if align == "left":
                pass
            elif align in {"right", "decimal"}:
                pass
            elif align == "center":
                pass
            elif align == "foo":
                pass
# 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_segment_with_colons

# unit tests

# --- Basic Test Cases ---

def test_pipe_segment_left_basic():
    # Test left alignment, typical width
    codeflash_output = _pipe_segment_with_colons("left", 5)
    codeflash_output = _pipe_segment_with_colons("left", 3)
    codeflash_output = _pipe_segment_with_colons("left", 1)

def test_pipe_segment_right_basic():
    # Test right alignment, typical width
    codeflash_output = _pipe_segment_with_colons("right", 5)
    codeflash_output = _pipe_segment_with_colons("right", 3)
    codeflash_output = _pipe_segment_with_colons("right", 1)

def test_pipe_segment_decimal_basic():
    # Test decimal alignment, which is treated like right
    codeflash_output = _pipe_segment_with_colons("decimal", 6)
    codeflash_output = _pipe_segment_with_colons("decimal", 2)
    codeflash_output = _pipe_segment_with_colons("decimal", 1)

def test_pipe_segment_center_basic():
    # Test center alignment, typical width
    codeflash_output = _pipe_segment_with_colons("center", 5)
    codeflash_output = _pipe_segment_with_colons("center", 3)
    codeflash_output = _pipe_segment_with_colons("center", 2)
    codeflash_output = _pipe_segment_with_colons("center", 1)  # w-2 = -1, so "" + ":" = ":"

def test_pipe_segment_default_basic():
    # Test default (unrecognized alignment) returns just dashes
    codeflash_output = _pipe_segment_with_colons("none", 4)
    codeflash_output = _pipe_segment_with_colons("", 2)
    codeflash_output = _pipe_segment_with_colons(None, 3)

# --- Edge Test Cases ---

def test_pipe_segment_zero_width():
    # Edge: width 0 should return empty string for all alignments
    for align in ["left", "right", "center", "decimal", "none"]:
        codeflash_output = _pipe_segment_with_colons(align, 0)

def test_pipe_segment_negative_width():
    # Edge: negative widths should return empty string (since "-"*-ve = "")
    for align in ["left", "right", "center", "decimal", "none"]:
        codeflash_output = _pipe_segment_with_colons(align, -3)

def test_pipe_segment_nonstring_align():
    # Edge: align is not a string (e.g., int, float, bool, object)
    class Dummy: pass
    codeflash_output = _pipe_segment_with_colons(123, 4)
    codeflash_output = _pipe_segment_with_colons(3.14, 2)
    codeflash_output = _pipe_segment_with_colons(True, 3)
    codeflash_output = _pipe_segment_with_colons(Dummy(), 5)

def test_pipe_segment_minimum_widths():
    # Edge: minimum widths for each align
    # left, right, decimal with colwidth=1 should be ":"
    codeflash_output = _pipe_segment_with_colons("left", 1)
    codeflash_output = _pipe_segment_with_colons("right", 1)
    codeflash_output = _pipe_segment_with_colons("decimal", 1)
    # center with colwidth=1 or 2 should be "::"
    codeflash_output = _pipe_segment_with_colons("center", 1)
    codeflash_output = _pipe_segment_with_colons("center", 2)

def test_pipe_segment_large_negative_width():
    # Edge: very large negative width
    codeflash_output = _pipe_segment_with_colons("left", -100)
    codeflash_output = _pipe_segment_with_colons("center", -100)

def test_pipe_segment_case_sensitivity():
    # Edge: alignment is case-sensitive, so "Left" is not "left"
    codeflash_output = _pipe_segment_with_colons("Left", 5)
    codeflash_output = _pipe_segment_with_colons("RIGHT", 3)

# --- Large Scale Test Cases ---

def test_pipe_segment_large_width_left():
    # Large: left alignment, large width
    w = 999
    codeflash_output = _pipe_segment_with_colons("left", w); result = codeflash_output

def test_pipe_segment_large_width_right():
    # Large: right alignment, large width
    w = 999
    codeflash_output = _pipe_segment_with_colons("right", w); result = codeflash_output

def test_pipe_segment_large_width_center():
    # Large: center alignment, large width
    w = 999
    codeflash_output = _pipe_segment_with_colons("center", w); result = codeflash_output

def test_pipe_segment_large_width_default():
    # Large: default alignment, large width
    w = 999
    codeflash_output = _pipe_segment_with_colons("foobar", w); result = codeflash_output

def test_pipe_segment_all_alignments_large_width():
    # Large: all alignments, random large width
    w = 500
    alignments = ["left", "right", "center", "decimal", "foobar", None]
    expected = [
        ":" + "-"*(w-1),
        "-"*(w-1) + ":",
        ":" + "-"*(w-2) + ":",
        "-"*(w-1) + ":",
        "-"*w,
        "-"*w
    ]
    for align, exp in zip(alignments, expected):
        codeflash_output = _pipe_segment_with_colons(align, w)

def test_pipe_segment_various_widths_and_alignments():
    # Large: test a sweep of widths and alignments for consistency
    for w in range(1, 20):
        codeflash_output = _pipe_segment_with_colons("left", w)
        codeflash_output = _pipe_segment_with_colons("right", w)
        codeflash_output = _pipe_segment_with_colons("center", w)
        codeflash_output = _pipe_segment_with_colons("decimal", w)
        codeflash_output = _pipe_segment_with_colons("foobar", w)

# --- Additional Robustness Tests ---

def test_pipe_segment_with_colons_mutation_resistance():
    # Test that the function is sensitive to off-by-one errors
    # If any dash count is off by one, this will fail
    for w in range(1, 10):
        # left
        codeflash_output = _pipe_segment_with_colons("left", w); seg = codeflash_output
        # right
        codeflash_output = _pipe_segment_with_colons("right", w); seg = codeflash_output
        # center
        codeflash_output = _pipe_segment_with_colons("center", w); seg = codeflash_output
        # decimal
        codeflash_output = _pipe_segment_with_colons("decimal", w); seg = codeflash_output

def test_pipe_segment_with_colons_output_type():
    # Test that the output is always a string
    for align in ["left", "right", "center", "decimal", "foobar", None]:
        for w in [0, 1, 5, 10]:
            pass
# 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.25.08 and push.