⚡️ Speed up function extract_hunk_lines_from_patch by 17%

[codeflash-ai]

📄 17% (0.17x) speedup for extract_hunk_lines_from_patch in pr_agent/algo/git_patch_processing.py

⏱️ Runtime : 1.39 milliseconds → 1.19 milliseconds (best of 642 runs)

📝 Explanation and details

The optimized code achieves a 16% speedup through three key optimizations:

1. Regex Compilation Hoisting (Major Impact)

• Moved RE_HUNK_HEADER regex compilation from inside the function to module-level scope
• Original code recompiled the regex on every function call (15.7% of total time in profiler)
• This single change eliminates repeated compilation overhead, providing the largest performance gain

2. String Concatenation Optimization

• Replaced string concatenation (+=) with list accumulation and final ''.join()
• Original: selected_lines += line + '\n' and patch_with_lines_str += line + '\n'
• Optimized: selected_lines_lst.append(line + '\n') then ''.join(selected_lines_lst)
• String concatenation in Python creates new string objects each time, causing O(n²) behavior for large patches

3. Redundant String Operations Elimination

• Cached side.lower() as lower_side to avoid repeated lowercasing in the inner loop
• Eliminates multiple .lower() calls that were happening for every line processed

Performance Benefits by Test Case:

• Large patches see the biggest gains (24-39% speedup): String concatenation optimization shines with many lines
• Multiple function calls benefit most from regex hoisting: Tests with repeated calls show consistent 6-17% improvements
• Small patches still benefit (4-17% speedup): Regex compilation removal helps even single-use cases

The optimizations maintain identical functionality while significantly improving performance, especially for the common use case of processing large git patches with many hunks and lines.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import re
import traceback

# imports
import pytest
from pr_agent.algo.git_patch_processing import extract_hunk_lines_from_patch

# --- Unit tests ---

# 1. BASIC TEST CASES

def test_basic_addition_right_side():
    # Test extracting added lines on right side
    patch = (
        "@@ -1,2 +1,3 @@\n"
        " line1\n"
        "+line2_added\n"
        " line3\n"
    )
    # Should extract only 'line2_added' from the right (added lines)
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "foo.py", line_start=2, line_end=2, side="right"
    ) # 7.31μs -> 6.73μs (8.61% faster)

def test_basic_context_lines_left_side():
    # Should extract context lines from left side (unchanged lines)
    patch = (
        "@@ -3,2 +3,2 @@\n"
        " foo\n"
        "-bar\n"
        "+baz\n"
        " qux\n"
    )
    # Extract line 3 from left (should be 'foo')
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "bar.py", line_start=3, line_end=3, side="left"
    ) # 7.20μs -> 6.58μs (9.30% faster)

def test_basic_range_right_side():
    # Should extract a range of right-side lines
    patch = (
        "@@ -1,1 +1,3 @@\n"
        "-a\n"
        "+b\n"
        "+c\n"
        "+d\n"
    )
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "baz.py", line_start=1, line_end=3, side="right"
    ) # 7.32μs -> 6.83μs (7.07% faster)

def test_basic_multiple_hunks():
    # Patch with two hunks, only one matches the range
    patch = (
        "@@ -1,2 +1,2 @@\n"
        " line1\n"
        "-line2\n"
        "+line2_mod\n"
        "@@ -10,2 +10,2 @@\n"
        " ten\n"
        "-eleven\n"
        "+eleven_mod\n"
    )
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "multi.py", line_start=10, line_end=11, side="right"
    ) # 9.21μs -> 8.68μs (6.09% faster)

# 2. EDGE TEST CASES

def test_empty_patch():
    # Empty patch string
    pwl, sel = extract_hunk_lines_from_patch(
        "", "empty.py", 1, 1, "right"
    ) # 1.81μs -> 1.59μs (13.8% faster)

def test_patch_with_no_hunk_headers():
    # Patch with no hunk headers
    patch = "just some text\nnot a patch\n"
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "nohunk.py", 1, 1, "right"
    ) # 3.27μs -> 2.85μs (14.5% faster)

def test_hunk_with_no_changes():
    # Hunk header but only context lines
    patch = (
        "@@ -1,2 +1,2 @@\n"
        " foo\n"
        " bar\n"
    )
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "nochange.py", 1, 2, "right"
    ) # 6.26μs -> 6.00μs (4.35% faster)

def test_no_newline_at_end_of_file():
    # Should ignore lines with 'no newline at end of file'
    patch = (
        "@@ -1,2 +1,2 @@\n"
        " foo\n"
        "-bar\n"
        "+baz\n"
        "\\ No newline at end of file\n"
    )
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "nonewline.py", 1, 2, "right"
    ) # 6.95μs -> 6.61μs (5.28% faster)

def test_remove_trailing_chars_false():
    # Should not strip trailing newlines if remove_trailing_chars is False
    patch = (
        "@@ -1,1 +1,2 @@\n"
        "+foo\n"
        "+bar\n"
    )
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "trailing.py", 1, 2, "right", remove_trailing_chars=False
    ) # 6.28μs -> 5.86μs (7.10% faster)

def test_invalid_hunk_header():
    # Should handle invalid hunk header gracefully
    patch = (
        "@@ -a,b +c,d @@\n"
        " foo\n"
        "+bar\n"
    )
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "badheader.py", 1, 2, "right"
    ) # 264μs -> 263μs (0.416% faster)

def test_side_case_insensitivity():
    # Side should be case insensitive
    patch = (
        "@@ -1,1 +1,2 @@\n"
        "+foo\n"
        "+bar\n"
    )
    pwl1, sel1 = extract_hunk_lines_from_patch(
        patch, "foo.py", 1, 2, "RIGHT"
    ) # 7.40μs -> 6.81μs (8.65% faster)
    pwl2, sel2 = extract_hunk_lines_from_patch(
        patch, "foo.py", 1, 2, "left"
    ) # 3.56μs -> 3.29μs (8.05% faster)

def test_line_range_outside_hunk():
    # Should skip hunks that do not match the requested line range
    patch = (
        "@@ -10,2 +10,2 @@\n"
        " ten\n"
        "-eleven\n"
        "+eleven_mod\n"
    )
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "skip.py", 1, 2, "right"
    ) # 6.05μs -> 5.56μs (8.83% faster)

def test_deleted_lines_not_selected_right():
    # Deleted lines should not be included on right side
    patch = (
        "@@ -1,2 +1,1 @@\n"
        "-foo\n"
        "-bar\n"
        " baz\n"
    )
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "del.py", 1, 2, "right"
    ) # 6.82μs -> 6.30μs (8.22% faster)

def test_deleted_lines_selected_left():
    # On left side, deleted lines can be selected (as context lines)
    patch = (
        "@@ -1,2 +1,1 @@\n"
        "foo\n"
        "-bar\n"
        "baz\n"
    )
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "del.py", 1, 2, "left"
    ) # 6.86μs -> 6.12μs (12.1% faster)

def test_hunk_header_with_section_header():
    # Hunk header with a section header at the end
    patch = (
        "@@ -1,2 +1,3 @@ def foo():\n"
        " foo\n"
        "+bar\n"
        " baz\n"
    )
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "section.py", 2, 2, "right"
    ) # 6.93μs -> 6.57μs (5.46% faster)

def test_hunk_header_with_zero_size():
    # Hunk header with zero size (e.g. @@ -0,0 +1,2 @@)
    patch = (
        "@@ -0,0 +1,2 @@\n"
        "+foo\n"
        "+bar\n"
    )
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "zero.py", 1, 2, "right"
    ) # 6.45μs -> 5.81μs (11.0% faster)

# 3. LARGE SCALE TEST CASES

def test_large_patch_right_side():
    # Large patch with many added lines
    lines = [f"+line{i}" for i in range(1, 501)]
    patch = "@@ -1,1 +1,500 @@\n" + "\n".join(lines) + "\n"
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "large.py", 1, 500, "right"
    ) # 152μs -> 109μs (38.7% faster)

def test_large_patch_left_side():
    # Large patch with many context lines
    lines = [f" line{i}" for i in range(1, 501)]
    patch = "@@ -1,500 +1,1 @@\n" + "\n".join(lines) + "\n"
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "largeleft.py", 1, 500, "left"
    ) # 145μs -> 107μs (35.2% faster)

def test_large_patch_multiple_hunks():
    # Large patch with multiple hunks, only one matches
    hunk1 = "@@ -1,100 +1,100 @@\n" + "\n".join(f" line{i}" for i in range(1, 101))
    hunk2 = "@@ -200,100 +200,100 @@\n" + "\n".join(f" line{i}" for i in range(200, 300))
    patch = hunk1 + "\n" + hunk2 + "\n"
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "multihunks.py", 200, 299, "left"
    ) # 44.9μs -> 36.1μs (24.5% faster)

def test_large_patch_performance():
    # Large patch, ensure it completes quickly and correctly
    lines = [f"+add{i}" for i in range(1, 1001)]
    patch = "@@ -1,1 +1,1000 @@\n" + "\n".join(lines) + "\n"
    pwl, sel = extract_hunk_lines_from_patch(
        patch, "perf.py", 1, 1000, "right"
    ) # 297μs -> 230μs (29.4% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import re
import traceback

# imports
import pytest
from pr_agent.algo.git_patch_processing import extract_hunk_lines_from_patch

# unit tests

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

def test_basic_single_hunk_right_side():
    # Basic patch with one hunk, right side selection
    patch = (
        "@@ -1,2 +1,3 @@\n"
        " line1\n"
        "+line2\n"
        " line3\n"
    )
    file_name = "foo.py"
    # Select lines 1-2 on right side (should get line1 and +line2)
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 1, 2, "right") # 7.38μs -> 6.91μs (6.83% faster)

def test_basic_single_hunk_left_side():
    # Basic patch with one hunk, left side selection
    patch = (
        "@@ -2,2 +2,3 @@\n"
        " lineA\n"
        "-lineB\n"
        " lineC\n"
    )
    file_name = "bar.py"
    # Select lines 2-3 on left side (should get lineA and -lineB)
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 2, 3, "left") # 6.98μs -> 6.38μs (9.30% faster)

def test_basic_multiple_hunks():
    # Patch with two hunks, select from second hunk
    patch = (
        "@@ -1,2 +1,2 @@\n"
        " foo\n"
        " bar\n"
        "@@ -4,2 +4,2 @@\n"
        " baz\n"
        "+qux\n"
    )
    file_name = "baz.py"
    # Select lines 4-5 on right side (should get baz and +qux)
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 4, 5, "right") # 8.05μs -> 7.52μs (7.14% faster)

def test_basic_remove_trailing_chars_false():
    # Test with remove_trailing_chars=False
    patch = (
        "@@ -1,1 +1,2 @@\n"
        " a\n"
        "+b\n"
    )
    file_name = "test.py"
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 1, 2, "right", remove_trailing_chars=False) # 6.33μs -> 5.95μs (6.49% faster)

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

def test_empty_patch():
    # Empty patch string
    patch = ""
    file_name = "empty.py"
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 1, 2, "right") # 1.83μs -> 1.57μs (17.0% faster)

def test_no_hunk_headers():
    # Patch with no hunk header
    patch = " some random text\n not a diff\n"
    file_name = "random.txt"
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 1, 2, "right") # 3.41μs -> 3.00μs (13.7% faster)

def test_hunk_header_with_missing_size():
    # Patch with hunk header missing size
    patch = (
        "@@ -5 +10 @@\n"
        " foo\n"
        "+bar\n"
    )
    file_name = "missing_size.py"
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 10, 11, "right") # 6.84μs -> 6.42μs (6.48% faster)

def test_hunk_header_with_section_header():
    # Hunk header with section header
    patch = (
        "@@ -1,3 +1,4 @@ def func():\n"
        " a\n"
        "+b\n"
        " c\n"
    )
    file_name = "section.py"
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 1, 2, "right") # 7.30μs -> 6.73μs (8.49% faster)

def test_hunk_header_with_no_newline_at_end_of_file():
    # Patch with "No newline at end of file"
    patch = (
        "@@ -1,1 +1,2 @@\n"
        " foo\n"
        "+bar\n"
        "\\ No newline at end of file\n"
    )
    file_name = "nonewline.py"
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 1, 2, "right") # 7.00μs -> 6.39μs (9.52% faster)

def test_hunk_header_zero_size():
    # Patch with zero size in hunk header
    patch = (
        "@@ -0,0 +1,1 @@\n"
        "+firstline\n"
    )
    file_name = "zeroline.py"
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 1, 1, "right") # 5.96μs -> 5.68μs (4.91% faster)

def test_hunk_header_negative_line_range():
    # Negative line range (should return empty selected)
    patch = (
        "@@ -1,2 +1,2 @@\n"
        " foo\n"
        " bar\n"
    )
    file_name = "neg.py"
    out, selected = extract_hunk_lines_from_patch(patch, file_name, -1, -1, "right") # 5.26μs -> 4.86μs (8.30% faster)

def test_hunk_header_line_range_outside_hunk():
    # Line range not covered by any hunk
    patch = (
        "@@ -1,2 +1,2 @@\n"
        " foo\n"
        " bar\n"
    )
    file_name = "outside.py"
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 100, 101, "right") # 5.26μs -> 4.65μs (13.0% faster)

def test_side_case_insensitive():
    # Side argument is case insensitive
    patch = (
        "@@ -1,1 +1,2 @@\n"
        " a\n"
        "+b\n"
    )
    file_name = "side.py"
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 1, 2, "RIGHT") # 6.38μs -> 5.64μs (13.0% faster)
    out2, selected2 = extract_hunk_lines_from_patch(patch, file_name, 1, 2, "LEFT") # 3.41μs -> 3.17μs (7.60% faster)

def test_deleted_lines_not_selected_right():
    # Deleted lines should not be selected on right side
    patch = (
        "@@ -1,2 +1,1 @@\n"
        " foo\n"
        "-bar\n"
    )
    file_name = "deleted.py"
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 1, 2, "right") # 6.22μs -> 5.60μs (11.0% faster)

def test_deleted_lines_selected_left():
    # Deleted lines should be selected on left side
    patch = (
        "@@ -1,2 +1,1 @@\n"
        " foo\n"
        "-bar\n"
    )
    file_name = "deleted_left.py"
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 1, 2, "left") # 6.15μs -> 5.56μs (10.6% faster)

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

def test_large_patch_many_hunks():
    # Large patch with multiple hunks, select from last hunk
    hunks = []
    for i in range(1, 50):
        hunks.append(f"@@ -{i},2 +{i},2 @@\n line{i}\n+added{i}\n")
    patch = "\n".join(hunks)
    file_name = "large.py"
    # Select lines from last hunk
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 49, 50, "right") # 58.8μs -> 55.3μs (6.45% faster)

def test_large_patch_long_lines():
    # Large patch with very long lines
    long_line = "x" * 500
    patch = (
        "@@ -1,1 +1,1 @@\n"
        f"{long_line}\n"
    )
    file_name = "longlines.py"
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 1, 1, "right") # 6.75μs -> 6.21μs (8.85% faster)

def test_large_patch_many_lines_in_hunk():
    # Patch with hunk containing many lines
    patch_lines = ["@@ -1,1000 +1,1000 @@\n"]
    for i in range(1, 1001):
        patch_lines.append(f" line{i}")
    patch = "".join(patch_lines)
    file_name = "manylines.py"
    # Select lines 900-910 on right side
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 900, 910, "right") # 14.3μs -> 13.3μs (7.98% faster)
    for i in range(900, 911):
        pass

def test_large_patch_performance():
    # Patch with 100 hunks, each with 10 lines
    hunks = []
    for i in range(1, 101):
        hunks.append(f"@@ -{i*10},10 +{i*10},10 @@\n" + "\n".join(f" line{j}" for j in range(i*10, i*10+10)))
    patch = "\n".join(hunks)
    file_name = "perf.py"
    # Select lines from hunk 50
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 500, 509, "right") # 171μs -> 158μs (7.72% faster)
    for i in range(500, 510):
        pass

def test_large_patch_mixed_add_delete():
    # Patch with mix of added and deleted lines
    patch_lines = ["@@ -1,100 +1,100 @@\n"]
    for i in range(1, 101):
        if i % 3 == 0:
            patch_lines.append(f"+added{i}")
        elif i % 5 == 0:
            patch_lines.append(f"-deleted{i}")
        else:
            patch_lines.append(f" line{i}")
    patch = "\n".join(patch_lines)
    file_name = "mixed.py"
    out, selected = extract_hunk_lines_from_patch(patch, file_name, 1, 100, "right") # 39.2μs -> 29.4μs (33.1% faster)
    # Check that added lines are present, deleted are not
    for i in range(1, 101):
        if i % 3 == 0:
            pass
        elif i % 5 == 0:
            pass
        else:
            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-extract_hunk_lines_from_patch-mgvy70ac and push.