⚡️ Speed up function generate_bbdc_table by 42%

[codeflash-ai]

📄 42% (0.42x) speedup for generate_bbdc_table in pr_agent/tools/pr_help_message.py

⏱️ Runtime : 897 microseconds → 633 microseconds (best of 799 runs)

📝 Explanation and details

The optimized code achieves a 41% speedup through two key performance improvements:

1. Precomputing array lengths: Instead of calling len(column_arr_1) and len(column_arr_2) on every loop iteration (7,845 times each in the profiler), the optimized version stores these values once as len1 and len2. This eliminates ~15,690 redundant function calls.

2. List accumulation + join vs string concatenation: The original code uses data_rows += f"| {col1} | {col2} |\n" which creates a new string object on each iteration due to string immutability in Python. The optimized version builds a list with append() operations and then uses ''.join() to create the final string in one operation.

Performance characteristics by test case:

• Small inputs (≤3 rows): The optimization shows modest overhead (6-17% slower) due to the additional setup cost of creating the list and precomputing lengths
• Large inputs (≥500 rows): The optimization shines with 39-48% speedups, as the quadratic behavior of string concatenation becomes dominant

The line profiler shows the string concatenation line dropped from 29.8% to 28.6% of total time, while the new ''.join() operation only takes 0.6% of total time, demonstrating the efficiency gain from avoiding repeated string object creation.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from pr_agent.tools.pr_help_message import generate_bbdc_table

# unit tests

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

def test_basic_equal_length():
    # Test with two lists of equal length
    col1 = ["A", "B"]
    col2 = ["Desc A", "Desc B"]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "| A | Desc A |\n"
        "| B | Desc B |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 1.79μs -> 1.98μs (9.74% slower)

def test_basic_empty_lists():
    # Test with both lists empty
    col1 = []
    col2 = []
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 1.01μs -> 1.23μs (17.3% slower)

def test_basic_single_item():
    # Test with single item in each list
    col1 = ["X"]
    col2 = ["Y"]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "| X | Y |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 1.44μs -> 1.62μs (11.6% slower)

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

def test_edge_first_longer():
    # First column longer than second
    col1 = ["A", "B", "C"]
    col2 = ["Desc A"]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "| A | Desc A |\n"
        "| B |  |\n"
        "| C |  |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 1.97μs -> 2.06μs (4.18% slower)

def test_edge_second_longer():
    # Second column longer than first
    col1 = ["A"]
    col2 = ["Desc A", "Desc B", "Desc C"]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "| A | Desc A |\n"
        "|  | Desc B |\n"
        "|  | Desc C |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 2.00μs -> 2.06μs (2.86% slower)

def test_edge_non_string_values():
    # Non-string values in columns
    col1 = [None, 123, True]
    col2 = [False, 45.6, None]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "| None | False |\n"
        "| 123 | 45.6 |\n"
        "| True | None |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 3.73μs -> 4.02μs (7.14% slower)

def test_edge_empty_strings():
    # Empty strings as values
    col1 = ["", "A"]
    col2 = ["Desc", ""]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "|  | Desc |\n"
        "| A |  |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 1.69μs -> 1.81μs (6.69% slower)

def test_edge_special_characters():
    # Special characters in values
    col1 = ["|", "Tool\nName", "Tool\tName"]
    col2 = ["Desc|ription", "Desc\nLine", "Desc\tTab"]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "| | | Desc|ription |\n"
        "| Tool\nName | Desc\nLine |\n"
        "| Tool\tName | Desc\tTab |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 2.04μs -> 2.16μs (5.60% slower)

def test_edge_unicode_characters():
    # Unicode characters in values
    col1 = ["工具", "🛠️"]
    col2 = ["描述", "Description"]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "| 工具 | 描述 |\n"
        "| 🛠️ | Description |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 2.70μs -> 2.71μs (0.406% slower)

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

def test_large_equal_length():
    # Test with large lists of equal length
    n = 500
    col1 = [f"Tool{i}" for i in range(n)]
    col2 = [f"Desc{i}" for i in range(n)]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        + "".join(f"| Tool{i} | Desc{i} |\n" for i in range(n))
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 56.5μs -> 38.3μs (47.3% faster)

def test_large_first_longer():
    # First column much longer than second
    n1 = 800
    n2 = 500
    col1 = [f"Tool{i}" for i in range(n1)]
    col2 = [f"Desc{i}" for i in range(n2)]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        + "".join(
            f"| Tool{i} | {f'Desc{i}' if i < n2 else ''} |\n"
            for i in range(n1)
        )
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 87.6μs -> 59.0μs (48.4% faster)

def test_large_second_longer():
    # Second column much longer than first
    n1 = 500
    n2 = 800
    col1 = [f"Tool{i}" for i in range(n1)]
    col2 = [f"Desc{i}" for i in range(n2)]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        + "".join(
            f"| {f'Tool{i}' if i < n1 else ''} | Desc{i} |\n"
            for i in range(n2)
        )
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 88.3μs -> 59.4μs (48.8% faster)

def test_large_empty_first_column():
    # Large second column, empty first column
    n = 1000
    col1 = []
    col2 = [f"Desc{i}" for i in range(n)]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        + "".join(f"|  | Desc{i} |\n" for i in range(n))
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 102μs -> 70.9μs (45.1% faster)

def test_large_empty_second_column():
    # Large first column, empty second column
    n = 1000
    col1 = [f"Tool{i}" for i in range(n)]
    col2 = []
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        + "".join(f"| Tool{i} |  |\n" for i in range(n))
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 102μs -> 70.6μs (45.6% 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  # used for our unit tests
from pr_agent.tools.pr_help_message import generate_bbdc_table

# unit tests

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

def test_basic_equal_length():
    # Both columns have equal length
    col1 = ["A", "B"]
    col2 = ["desc1", "desc2"]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "| A | desc1 |\n"
        "| B | desc2 |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 1.90μs -> 2.14μs (11.3% slower)

def test_basic_unequal_length_col1_longer():
    # First column longer than second
    col1 = ["A", "B", "C"]
    col2 = ["desc1"]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "| A | desc1 |\n"
        "| B |  |\n"
        "| C |  |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 1.88μs -> 2.04μs (7.56% slower)

def test_basic_unequal_length_col2_longer():
    # Second column longer than first
    col1 = ["A"]
    col2 = ["desc1", "desc2", "desc3"]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "| A | desc1 |\n"
        "|  | desc2 |\n"
        "|  | desc3 |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 1.91μs -> 2.08μs (8.21% slower)

def test_basic_empty_columns():
    # Both columns are empty
    col1 = []
    col2 = []
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 1.05μs -> 1.23μs (14.4% slower)

def test_basic_one_empty_column():
    # First column empty, second has values
    col1 = []
    col2 = ["desc1", "desc2"]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "|  | desc1 |\n"
        "|  | desc2 |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 1.71μs -> 1.88μs (9.21% slower)

    # Second column empty, first has values
    col1 = ["A", "B"]
    col2 = []
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "| A |  |\n"
        "| B |  |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 1.05μs -> 1.15μs (8.43% slower)

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

def test_edge_single_element():
    # Both columns have a single element
    col1 = ["X"]
    col2 = ["Y"]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "| X | Y |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 1.27μs -> 1.52μs (16.5% slower)

def test_edge_special_characters():
    # Columns with special Markdown characters
    col1 = ["|", "*", "`"]
    col2 = ["[desc](url)", "desc*2*", "desc`3`"]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "| | | [desc](url) |\n"
        "| * | desc*2* |\n"
        "| ` | desc`3` |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 1.86μs -> 2.12μs (12.3% slower)

def test_edge_non_string_types():
    # Columns with non-string types (int, float, bool, None)
    col1 = [1, 2.5, True, None]
    col2 = ["desc1", None, False, 0]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "| 1 | desc1 |\n"
        "| 2.5 | None |\n"
        "| True | False |\n"
        "| None | 0 |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 4.19μs -> 4.26μs (1.67% slower)

def test_edge_long_strings():
    # Columns with very long strings
    long_str = "a" * 100
    col1 = [long_str]
    col2 = [long_str[::-1]]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        f"| {long_str} | {long_str[::-1]} |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 1.32μs -> 1.57μs (16.0% slower)

def test_edge_whitespace_strings():
    # Columns with whitespace strings
    col1 = [" ", "\t", "\n"]
    col2 = ["desc1", "desc2", "desc3"]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "|   | desc1 |\n"
        "| \t | desc2 |\n"
        "| \n | desc3 |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 1.81μs -> 1.92μs (5.52% slower)

def test_edge_empty_string_elements():
    # Columns containing empty string elements
    col1 = ["A", ""]
    col2 = ["desc1", ""]
    expected = (
        "| Tool  | Description | \n"
        "|--|--|\n"
        "| A | desc1 |\n"
        "|  |  |\n"
    )
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 1.59μs -> 1.81μs (12.1% slower)

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

def test_large_equal_length():
    # Large columns of equal length
    size = 500
    col1 = [f"Tool{i}" for i in range(size)]
    col2 = [f"Desc{i}" for i in range(size)]
    expected = "| Tool  | Description | \n|--|--|\n"
    for i in range(size):
        expected += f"| Tool{i} | Desc{i} |\n"
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 56.5μs -> 38.9μs (45.4% faster)

def test_large_unequal_length_col1_longer():
    # Large columns, first longer than second
    size1 = 800
    size2 = 700
    col1 = [f"T{i}" for i in range(size1)]
    col2 = [f"D{i}" for i in range(size2)]
    expected = "| Tool  | Description | \n|--|--|\n"
    for i in range(size1):
        col1_val = f"T{i}"
        col2_val = f"D{i}" if i < size2 else ""
        expected += f"| {col1_val} | {col2_val} |\n"
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 88.0μs -> 62.2μs (41.4% faster)

def test_large_unequal_length_col2_longer():
    # Large columns, second longer than first
    size1 = 300
    size2 = 900
    col1 = [f"T{i}" for i in range(size1)]
    col2 = [f"D{i}" for i in range(size2)]
    expected = "| Tool  | Description | \n|--|--|\n"
    for i in range(size2):
        col1_val = f"T{i}" if i < size1 else ""
        col2_val = f"D{i}"
        expected += f"| {col1_val} | {col2_val} |\n"
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 95.5μs -> 64.9μs (47.3% faster)

def test_large_empty_columns():
    # Large test with both columns empty
    col1 = []
    col2 = []
    expected = "| Tool  | Description | \n|--|--|\n"
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 1.08μs -> 1.28μs (16.1% slower)

def test_large_one_empty_column():
    # Large test with one empty column
    col1 = ["A"] * 1000
    col2 = []
    expected = "| Tool  | Description | \n|--|--|\n"
    for _ in range(1000):
        expected += "| A |  |\n"
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 100μs -> 68.7μs (46.6% faster)

def test_large_mixed_types():
    # Large test with mixed types in columns
    col1 = [i if i % 2 == 0 else str(i) for i in range(500)]
    col2 = [None if i % 2 == 0 else f"Desc{i}" for i in range(500)]
    expected = "| Tool  | Description | \n|--|--|\n"
    for i in range(500):
        col1_val = i if i % 2 == 0 else str(i)
        col2_val = "None" if i % 2 == 0 else f"Desc{i}"
        expected += f"| {col1_val} | {col2_val} |\n"
    codeflash_output = generate_bbdc_table(col1, col2); result = codeflash_output # 76.9μs -> 55.0μs (39.8% 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-generate_bbdc_table-mgzlg8n0 and push.