⚡️ Speed up function decouple_and_convert_to_hunks_with_lines_numbers by 14%

[codeflash-ai]

📄 14% (0.14x) speedup for decouple_and_convert_to_hunks_with_lines_numbers in pr_agent/algo/git_patch_processing.py

⏱️ Runtime : 1.41 milliseconds → 1.25 milliseconds (best of 571 runs)

📝 Explanation and details

The optimized code achieves a 13% speedup through two main optimizations:

1. String concatenation to list-based building (major improvement):

• Changed patch_with_lines_str from a string to a list that accumulates fragments
• Replaced patch_with_lines_str += f"..." operations with patch_with_lines_str.append(f"...")
• Used ''.join(patch_with_lines_str) at the end instead of repeated string concatenation
• This eliminates O(n²) behavior since Python strings are immutable - each concatenation creates a new string object

2. Optimized line type detection:

• Replaced any([line.startswith('+') for line in new_content_lines]) with custom any_plus_lines() function
• The custom functions use early-exit iteration instead of building temporary lists with list comprehensions
• This saves memory allocation and reduces iterations, especially beneficial for patches with many lines

3. Simplified exception handling:

• Removed the unnecessary try/except block in extract_hunk_headers() since the fallback case was actually more restrictive than the main case

The optimizations are most effective for large patches - the test results show the biggest improvements on large-scale cases:

• test_large_patch_additions(): 26.1% faster
• test_large_patch_mixed(): 24.2% faster
• test_large_patch_multiple_hunks(): 35.1% faster

Small patches show minimal or slightly negative impact due to the overhead of list operations, but the overall net benefit is substantial for real-world git patch processing scenarios.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import re
from enum import Enum
from types import SimpleNamespace

# imports
import pytest
from pr_agent.algo.git_patch_processing import \
    decouple_and_convert_to_hunks_with_lines_numbers


# --- Mocking EDIT_TYPE Enum for testing ---
class EDIT_TYPE(Enum):
    ADDED = 1
    MODIFIED = 2
    DELETED = 3
from pr_agent.algo.git_patch_processing import \
    decouple_and_convert_to_hunks_with_lines_numbers

# --- Unit tests ---

# Helper: create a mock file object
def make_file(filename='test.txt', edit_type=EDIT_TYPE.MODIFIED):
    return SimpleNamespace(filename=filename, edit_type=edit_type)

# 1. Basic Test Cases

def test_basic_addition():
    # Test a simple addition hunk
    patch = (
        "@@ -1,2 +1,3 @@\n"
        " line1\n"
        "+line2\n"
        " line3"
    )
    file = make_file('foo.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 9.12μs -> 9.34μs (2.31% slower)

def test_basic_deletion():
    # Test a simple deletion hunk
    patch = (
        "@@ -1,3 +1,2 @@\n"
        " line1\n"
        "-line2\n"
        " line3"
    )
    file = make_file('bar.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 9.34μs -> 9.21μs (1.49% faster)

def test_basic_modification():
    # Test a simple modification (delete and add in same hunk)
    patch = (
        "@@ -1,2 +1,2 @@\n"
        "-oldline\n"
        "+newline"
    )
    file = make_file('baz.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 8.05μs -> 8.02μs (0.312% faster)

def test_basic_context():
    # Test context lines (no + or -)
    patch = (
        "@@ -2,3 +2,3 @@\n"
        " line2\n"
        " line3\n"
        " line4"
    )
    file = make_file('context.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 7.54μs -> 7.61μs (0.946% slower)

def test_multiple_hunks():
    # Test a patch with two hunks
    patch = (
        "@@ -1,2 +1,3 @@\n"
        " line1\n"
        "+line2\n"
        " line3\n"
        "@@ -10,2 +11,3 @@\n"
        " foo\n"
        "+bar\n"
        " baz"
    )
    file = make_file('multi.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 13.1μs -> 12.8μs (2.79% faster)

# 2. Edge Test Cases

def test_empty_patch():
    # Empty patch string
    patch = ""
    file = make_file('empty.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 2.35μs -> 2.84μs (17.5% slower)

def test_file_deleted():
    # File deleted scenario
    patch = ""  # Patch is ignored for deleted files
    file = make_file('gone.txt', EDIT_TYPE.DELETED)
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 2.22μs -> 2.70μs (17.7% slower)

def test_no_file_object():
    # Patch with file=None
    patch = "@@ -1,1 +1,1 @@\n line"
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, None); result = codeflash_output # 6.32μs -> 6.31μs (0.206% faster)

def test_patch_with_no_hunks():
    # Patch with no hunk headers (invalid diff)
    patch = "line1\nline2"
    file = make_file('nohunk.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 3.50μs -> 3.93μs (11.0% slower)

def test_patch_with_no_newline_at_eof():
    # Patch with 'No newline at end of file' line
    patch = (
        "@@ -1,2 +1,2 @@\n"
        " line1\n"
        "-line2\n"
        "+line3\n"
        "\\ No newline at end of file"
    )
    file = make_file('nonewline.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 9.63μs -> 9.29μs (3.65% faster)

def test_patch_with_empty_lines_and_trailing_newlines():
    # Patch with empty lines and trailing newlines
    patch = (
        "@@ -1,2 +1,2 @@\n"
        "\n"
        "-foo\n"
        "+bar\n"
        "\n"
    )
    file = make_file('emptylines.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 10.2μs -> 10.3μs (0.536% slower)

def test_patch_with_section_header():
    # Patch with section header in hunk
    patch = (
        "@@ -1,2 +1,2 @@ section header\n"
        " line1\n"
        "-line2\n"
        "+line3"
    )
    file = make_file('section.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 9.36μs -> 9.11μs (2.69% faster)

def test_patch_with_zero_length_hunk():
    # Patch with zero-length hunk (should be ignored)
    patch = "@@ -0,0 +0,0 @@\n"
    file = make_file('zero.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 5.29μs -> 5.74μs (7.84% slower)

def test_patch_with_only_context_lines():
    # Patch with only context lines (no + or -)
    patch = "@@ -1,2 +1,2 @@\n line1\n line2"
    file = make_file('ctx.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 7.27μs -> 7.41μs (1.93% slower)

def test_patch_with_leading_trailing_spaces():
    # Patch with lines that have leading/trailing spaces
    patch = "@@ -1,2 +1,2 @@\n  line1  \n-line2 \n+ line3"
    file = make_file('spaces.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 8.95μs -> 8.79μs (1.76% faster)

def test_patch_with_multiple_plus_and_minus():
    # Patch with multiple additions and deletions
    patch = (
        "@@ -1,4 +1,5 @@\n"
        " line1\n"
        "-line2\n"
        "+lineA\n"
        " line3\n"
        "-line4\n"
        "+lineB"
    )
    file = make_file('plusminus.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 9.92μs -> 9.59μs (3.43% faster)

def test_patch_with_hunk_header_variations():
    # Patch with missing size fields in hunk header
    patch = "@@ -1 +1 @@\n line1\n-line2\n+line3"
    file = make_file('headervar.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 8.57μs -> 8.60μs (0.360% slower)

# 3. Large Scale Test Cases

def test_large_patch_additions():
    # Large patch with many additions
    n = 500
    patch_lines = ["@@ -1,0 +1,{0} @@".format(n)]
    patch_lines += [f"+line{i}" for i in range(1, n+1)]
    patch = "\n".join(patch_lines)
    file = make_file('largeadd.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 135μs -> 107μs (26.1% faster)
    # All lines should be present and numbered
    for i in range(1, n+1):
        pass

def test_large_patch_deletions():
    # Large patch with many deletions
    n = 500
    patch_lines = ["@@ -1,{0} +1,0 @@".format(n)]
    patch_lines += [f"-line{i}" for i in range(1, n+1)]
    patch = "\n".join(patch_lines)
    file = make_file('largedel.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 78.1μs -> 79.3μs (1.46% slower)
    for i in range(1, n+1):
        pass

def test_large_patch_mixed():
    # Large patch with mixed changes
    n = 250
    patch_lines = ["@@ -1,{0} +1,{0} @@".format(n)]
    for i in range(1, n+1):
        if i % 2 == 0:
            patch_lines.append(f"+add{i}")
        else:
            patch_lines.append(f"-del{i}")
    patch = "\n".join(patch_lines)
    file = make_file('largemix.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 71.7μs -> 57.7μs (24.2% faster)
    for i in range(1, n+1):
        if i % 2 == 0:
            pass
        else:
            pass

def test_large_patch_multiple_hunks():
    # Patch with many hunks (each with a single line change)
    n = 100
    patch_lines = []
    for i in range(n):
        patch_lines.append(f"@@ -{i+1},1 +{i+1},1 @@")
        patch_lines.append(f"-old{i+1}")
        patch_lines.append(f"+new{i+1}")
    patch = "\n".join(patch_lines)
    file = make_file('multihunks.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 220μs -> 163μs (35.1% faster)
    for i in range(1, n+1):
        pass

def test_large_patch_with_context():
    # Large patch with context lines and a few changes
    n = 100
    patch_lines = ["@@ -1,{0} +1,{0} @@".format(n)]
    for i in range(1, n+1):
        if i % 20 == 0:
            patch_lines.append(f"-old{i}")
            patch_lines.append(f"+new{i}")
        else:
            patch_lines.append(f" line{i}")
    patch = "\n".join(patch_lines)
    file = make_file('largectx.txt')
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 51.4μs -> 39.2μs (31.1% faster)
    for i in range(1, n+1):
        if i % 20 == 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.
#------------------------------------------------
from __future__ import annotations

import re
from types import SimpleNamespace

# imports
import pytest
from pr_agent.algo.git_patch_processing import \
    decouple_and_convert_to_hunks_with_lines_numbers


class EDIT_TYPE:
    DELETED = "deleted"
    MODIFIED = "modified"
    ADDED = "added"
from pr_agent.algo.git_patch_processing import \
    decouple_and_convert_to_hunks_with_lines_numbers

# unit tests

# Helper for file object
def make_file(filename, edit_type=None):
    f = SimpleNamespace()
    f.filename = filename
    if edit_type is not None:
        f.edit_type = edit_type
    return f

# ==== BASIC TEST CASES ====

def test_basic_addition_hunk():
    # Simple addition of a line
    patch = "@@ -1,2 +1,3 @@\n line1\n+line2\n line3"
    file = make_file("foo.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 8.43μs -> 8.37μs (0.765% faster)

def test_basic_deletion_hunk():
    # Simple deletion of a line
    patch = "@@ -1,3 +1,2 @@\n line1\n-line2\n line3"
    file = make_file("bar.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 8.78μs -> 8.49μs (3.33% faster)

def test_basic_modification_hunk():
    # Modification (replace line2 with line2b)
    patch = "@@ -1,3 +1,3 @@\n line1\n-line2\n+line2b\n line3"
    file = make_file("baz.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 9.13μs -> 8.76μs (4.27% faster)

def test_basic_no_changes():
    # No changes (patch is empty)
    patch = ""
    file = make_file("empty.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 2.17μs -> 2.51μs (13.5% slower)

def test_basic_file_deleted():
    # File deleted
    file = make_file("gone.txt", EDIT_TYPE.DELETED)
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers("", file); result = codeflash_output # 2.44μs -> 2.78μs (12.3% slower)

def test_basic_file_added():
    # File added (simulate by giving a patch with only additions)
    patch = "@@ -0,0 +1,2 @@\n+foo\n+bar"
    file = make_file("new.txt", EDIT_TYPE.ADDED)
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 8.06μs -> 7.85μs (2.70% faster)

# ==== EDGE TEST CASES ====

def test_edge_empty_patch_and_none_file():
    # Patch is empty and file is None
    patch = ""
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, None); result = codeflash_output # 1.74μs -> 2.06μs (15.7% slower)

def test_edge_patch_with_no_hunk_header():
    # Patch with no hunk header, just lines
    patch = " line1\n+line2\n line3"
    file = make_file("noheader.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 3.68μs -> 4.10μs (10.4% slower)

def test_edge_patch_with_multiple_hunks():
    # Patch with two hunks
    patch = (
        "@@ -1,2 +1,3 @@\n line1\n+line2\n line3\n"
        "@@ -10,2 +11,3 @@\n foo\n-bar\n+baz\nqux"
    )
    file = make_file("multi.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 14.4μs -> 13.3μs (8.59% faster)

def test_edge_patch_with_no_newline_at_end_of_file():
    # Patch with 'No newline at end of file' marker
    patch = "@@ -1,2 +1,3 @@\n line1\n+line2\n line3\n\\ No newline at end of file"
    file = make_file("nonl.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 8.62μs -> 8.69μs (0.863% slower)

def test_edge_patch_with_blank_lines():
    # Patch with blank lines inside hunk
    patch = "@@ -1,3 +1,4 @@\n line1\n\n+line2\n line3"
    file = make_file("blank.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 9.78μs -> 9.60μs (1.90% faster)

def test_edge_patch_with_section_header():
    # Patch with section header (function name after @@)
    patch = "@@ -1,2 +1,3 @@ def foo\n line1\n+line2\n line3"
    file = make_file("section.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 8.46μs -> 8.25μs (2.59% faster)

def test_edge_patch_with_zero_start_lines():
    # Patch with zero start lines
    patch = "@@ -0,0 +1,2 @@\n+foo\n+bar"
    file = make_file("zerostart.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 7.41μs -> 7.41μs (0.041% faster)

def test_edge_patch_with_only_deletions():
    # Patch with only deletions
    patch = "@@ -1,2 +0,0 @@\n-line1\n-line2"
    file = make_file("onlydel.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 5.64μs -> 6.10μs (7.51% slower)

def test_edge_patch_with_only_context_lines():
    # Patch with only context lines (no + or -)
    patch = "@@ -1,2 +1,2 @@\n line1\n line2"
    file = make_file("context.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 6.93μs -> 6.97μs (0.631% slower)

def test_edge_patch_with_trailing_blank_lines():
    # Patch with trailing blank lines after hunk
    patch = "@@ -1,2 +1,3 @@\n line1\n+line2\n line3\n\n"
    file = make_file("trailingblank.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 8.92μs -> 8.90μs (0.213% faster)

def test_edge_patch_with_leading_blank_lines():
    # Patch with leading blank lines before hunk
    patch = "\n\n@@ -1,2 +1,3 @@\n line1\n+line2\n line3"
    file = make_file("leadingblank.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 10.6μs -> 10.3μs (3.63% faster)

def test_edge_patch_with_non_ascii_characters():
    # Patch with non-ASCII unicode characters
    patch = "@@ -1,2 +1,3 @@\n line1\n+línea2\n line3"
    file = make_file("unicode.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 9.78μs -> 9.30μs (5.14% faster)

# ==== LARGE SCALE TEST CASES ====

def test_large_patch_many_lines():
    # Large patch with 1000 lines added
    n = 1000
    patch_lines = ["@@ -0,0 +1,%d @@\n" % n]
    patch_lines += [f"+line{i}" for i in range(1, n+1)]
    patch = "".join(patch_lines)
    file = make_file("big.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 15.9μs -> 15.7μs (0.949% faster)
    # Should contain all lines with correct line numbers
    for i in [1, n//2, n]:
        pass
    # Should not be absurdly slow or crash

def test_large_patch_many_hunks():
    # Large patch with 10 hunks, each with 10 lines
    hunks = []
    for h in range(10):
        start = h * 10 + 1
        hunks.append(f"@@ -{start},10 +{start},11 @@\n")
        for i in range(10):
            hunks.append(f" line{start+i}\n")
        hunks.append(f"+line{start+10}\n")
    patch = "".join(hunks)
    file = make_file("multihunks.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 66.5μs -> 56.8μs (17.1% faster)
    # Should contain some added lines
    for h in range(10):
        added_line = f"{h*10+11} +line{h*10+11}"

def test_large_patch_with_long_lines():
    # Patch with very long lines (500 chars)
    long_line = "x" * 500
    patch = f"@@ -1,1 +1,2 @@\n {long_line}\n+{long_line[::-1]}"
    file = make_file("longlines.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 9.44μs -> 9.32μs (1.35% faster)

def test_large_patch_mixed_add_delete():
    # Patch with 500 added, 500 deleted lines
    n = 500
    patch_lines = ["@@ -1,%d +1,%d @@\n" % (n, n)]
    patch_lines += [f"-del{i}\n" for i in range(1, n+1)]
    patch_lines += [f"+add{i}\n" for i in range(1, n+1)]
    patch = "".join(patch_lines)
    file = make_file("mix.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 261μs -> 226μs (15.4% faster)

def test_large_patch_with_only_context_lines():
    # Patch with 1000 context lines
    n = 1000
    patch_lines = [f"@@ -1,{n} +1,{n} @@\n"]
    patch_lines += [f" line{i}\n" for i in range(1, n+1)]
    patch = "".join(patch_lines)
    file = make_file("contextbig.txt")
    codeflash_output = decouple_and_convert_to_hunks_with_lines_numbers(patch, file); result = codeflash_output # 238μs -> 225μs (5.64% faster)
    # Should show all lines with correct line numbers
    for i in [1, n//2, n]:
        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-decouple_and_convert_to_hunks_with_lines_numbers-mgvy09bl and push.