⚡️ Speed up function get_diff_lines_count by 12% in PR #274 (skip-formatting-for-large-diffs)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #274

If you approve this dependent PR, these changes will be merged into the original PR branch skip-formatting-for-large-diffs.

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

---

📄 12% (0.12x) speedup for get_diff_lines_count in codeflash/code_utils/formatter.py

⏱️ Runtime : 2.93 milliseconds → 2.62 milliseconds (best of 301 runs)

📝 Explanation and details

Here’s a more optimized version of your program.

Optimization rationale:

• Eliminated the nested function, reducing overhead.
• Avoided creating an intermediate list, directly counting matching lines.
• Used string indexing instead of startswith() for single-char checks for slightly less overhead.
• Preserved all relevant comments (there were none to preserve).

✅ Correctness verification report:

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

🌀 Generated Regression Tests Details

from __future__ import annotations

# imports
import pytest  # used for our unit tests
from codeflash.code_utils.formatter import get_diff_lines_count

# unit tests

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

def test_empty_string():
    # Empty diff should have zero changed lines
    codeflash_output = get_diff_lines_count("")

def test_no_diff_lines():
    # Diff with only context lines (no + or - at start)
    diff = " context line 1\n context line 2"
    codeflash_output = get_diff_lines_count(diff)

def test_only_added_lines():
    # All lines are additions
    diff = "+added line 1\n+added line 2"
    codeflash_output = get_diff_lines_count(diff)

def test_only_removed_lines():
    # All lines are deletions
    diff = "-removed line 1\n-removed line 2"
    codeflash_output = get_diff_lines_count(diff)

def test_mixed_added_and_removed_lines():
    # Mix of added and removed lines
    diff = "+added 1\n-context 1\n+added 2\n-context 2"
    codeflash_output = get_diff_lines_count(diff)

def test_diff_with_headers():
    # Diff with file headers should not count them
    diff = "--- a/file.txt\n+++ b/file.txt\n+added line\n-context line"
    codeflash_output = get_diff_lines_count(diff)

def test_diff_with_context_and_changes():
    # Diff with context lines, headers, and changes
    diff = (
        "--- a/file.txt\n"
        "+++ b/file.txt\n"
        "@@ -1,3 +1,3 @@\n"
        " line 1\n"
        "+added line\n"
        "-removed line\n"
        " unchanged"
    )
    codeflash_output = get_diff_lines_count(diff)

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

def test_lines_with_only_plus_or_minus():
    # Lines that are just "+" or "-" should count
    diff = "+\n-\n+foo\n-bar"
    codeflash_output = get_diff_lines_count(diff)

def test_lines_with_leading_spaces():
    # Lines with spaces before + or - are not diff lines
    diff = " +not a diff line\n -not a diff line\n+real diff\n-real diff"
    codeflash_output = get_diff_lines_count(diff)

def test_lines_with_triple_plus_minus():
    # Lines starting with +++ or --- are headers, not diff lines
    diff = "+++ b/file\n--- a/file\n+++ not counted\n--- not counted\n+counted\n-counted"
    codeflash_output = get_diff_lines_count(diff)

def test_lines_with_multiple_plus_minus():
    # Lines starting with more than one + or - but not triple
    diff = "++double plus\n--double minus\n+single plus\n-single minus"
    # Only +single plus and -single minus should be counted
    codeflash_output = get_diff_lines_count(diff)

def test_lines_with_plus_minus_in_middle():
    # Lines with + or - not at start should not be counted
    diff = "context + line\ncontext - line\n+diff line\n-diff line"
    codeflash_output = get_diff_lines_count(diff)

def test_diff_with_blank_lines():
    # Blank lines should not be counted
    diff = "\n\n+added\n\n-removed\n\n"
    codeflash_output = get_diff_lines_count(diff)

def test_diff_with_only_headers():
    # Only headers, no changes
    diff = "--- a/file\n+++ b/file"
    codeflash_output = get_diff_lines_count(diff)

def test_diff_with_unicode_characters():
    # Unicode characters in diff lines
    diff = "+Añadido\n-Удалено\n context\n+++ b/archivo"
    codeflash_output = get_diff_lines_count(diff)

def test_diff_with_windows_line_endings():
    # Windows line endings (\r\n)
    diff = "+added line\r\n-context line\r\n unchanged\r\n+++ b/file\r\n"
    codeflash_output = get_diff_lines_count(diff.replace('\r\n', '\n'))

def test_diff_with_trailing_newline():
    # Diff ends with a newline
    diff = "+added\n-removed\n"
    codeflash_output = get_diff_lines_count(diff)

def test_diff_with_leading_and_trailing_whitespace():
    # Lines with leading/trailing whitespace after +/-
    diff = "+added   \n-removed\t\n context"
    codeflash_output = get_diff_lines_count(diff)

def test_diff_with_no_newlines():
    # Single line, no newline at end
    diff = "+added"
    codeflash_output = get_diff_lines_count(diff)

def test_diff_with_mixed_line_endings():
    # Mixed \n and \r\n
    diff = "+added 1\n-removed 1\r\n+added 2\r\n-context"
    # Normalize line endings for test
    normalized = diff.replace('\r\n', '\n')
    codeflash_output = get_diff_lines_count(normalized)

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

def test_large_diff_all_added():
    # Large diff with only added lines
    diff = "\n".join([f"+line {i}" for i in range(1000)])
    codeflash_output = get_diff_lines_count(diff)

def test_large_diff_all_removed():
    # Large diff with only removed lines
    diff = "\n".join([f"-line {i}" for i in range(1000)])
    codeflash_output = get_diff_lines_count(diff)

def test_large_diff_mixed_changes():
    # Large diff with alternating added and removed lines
    diff = "\n".join(
        [f"+add {i}" if i % 2 == 0 else f"-remove {i}" for i in range(1000)]
    )
    codeflash_output = get_diff_lines_count(diff)

def test_large_diff_with_headers_and_context():
    # Large diff with headers, context, and changes
    header = "--- a/largefile\n+++ b/largefile\n"
    context = "\n".join([f" context {i}" for i in range(500)])
    changes = "\n".join([f"+added {i}\n-removed {i}" for i in range(250)])
    diff = f"{header}{context}\n{changes}"
    # 250 added + 250 removed = 500
    codeflash_output = get_diff_lines_count(diff)

def test_large_diff_with_noise_lines():
    # Large diff with random lines that look similar but aren't diff lines
    diff_lines = []
    for i in range(500):
        diff_lines.append(f"+real {i}")
        diff_lines.append(f" +fake {i}")
        diff_lines.append(f"-real {i}")
        diff_lines.append(f"--- not a diff {i}")
        diff_lines.append(f"+++ not a diff {i}")
    diff = "\n".join(diff_lines)
    # Only lines starting with single + or - count: 500 + 500 = 1000
    codeflash_output = get_diff_lines_count(diff)

def test_large_diff_with_trailing_and_leading_blank_lines():
    # Large diff with many blank lines at start and end
    diff = "\n" * 100 + "\n".join([f"+line {i}" for i in range(500)]) + "\n" * 100
    codeflash_output = get_diff_lines_count(diff)

def test_large_diff_with_varied_content():
    # Large diff with a mix of all possible line types
    lines = []
    for i in range(250):
        lines.append(f"+added {i}")
        lines.append(f"-removed {i}")
        lines.append(f" context {i}")
        lines.append(f"+++ header {i}")
        lines.append(f"--- header {i}")
        lines.append(f"   +not diff {i}")
        lines.append(f"   -not diff {i}")
        lines.append("")
    diff = "\n".join(lines)
    # Only +added and -removed: 250 + 250 = 500
    codeflash_output = get_diff_lines_count(diff)
# 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

# imports
import pytest  # used for our unit tests
from codeflash.code_utils.formatter import get_diff_lines_count

# unit tests

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

def test_empty_string():
    # Test with an empty string input
    codeflash_output = get_diff_lines_count("")

def test_no_diff_lines():
    # Test with input that has no diff lines
    diff = " context line\n another context"
    codeflash_output = get_diff_lines_count(diff)

def test_only_added_lines():
    # Test with only added lines
    diff = "+added line 1\n+added line 2"
    codeflash_output = get_diff_lines_count(diff)

def test_only_removed_lines():
    # Test with only removed lines
    diff = "-removed line 1\n-removed line 2"
    codeflash_output = get_diff_lines_count(diff)

def test_mixed_added_removed_and_context():
    # Test with a mix of added, removed, and context lines
    diff = (
        " context line\n"
        "+added line\n"
        "-removed line\n"
        " unchanged line"
    )
    codeflash_output = get_diff_lines_count(diff)

def test_ignore_diff_headers():
    # Test that diff headers are ignored
    diff = (
        "--- a/file.txt\n"
        "+++ b/file.txt\n"
        "+added line\n"
        "-removed line\n"
        " context"
    )
    # Only "+added line" and "-removed line" count
    codeflash_output = get_diff_lines_count(diff)

def test_headers_only():
    # Test with only diff headers, no actual diff lines
    diff = "--- a/file.txt\n+++ b/file.txt"
    codeflash_output = get_diff_lines_count(diff)

def test_lines_with_plus_minus_not_at_start():
    # Test lines containing '+' or '-' not at the start
    diff = " context + not diff\n context - not diff"
    codeflash_output = get_diff_lines_count(diff)

def test_leading_spaces_before_plus_minus():
    # Test lines with leading spaces before +/-
    diff = " +not a diff line\n -not a diff line"
    codeflash_output = get_diff_lines_count(diff)

def test_actual_diff_lines_with_leading_whitespace():
    # Test lines with whitespace, but + or - is first char
    diff = "+ added line\n- removed line"
    codeflash_output = get_diff_lines_count(diff)

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

def test_lines_starting_with_multiple_plus_minus():
    # Test lines starting with multiple + or - (not headers)
    diff = "++not a header\n--not a header\n+real add\n-real remove"
    # ++ and -- are not headers, so should count as diff lines
    codeflash_output = get_diff_lines_count(diff)

def test_lines_starting_with_three_plus_minus():
    # Test lines starting with three + or - (should be recognized as headers and not counted)
    diff = "+++ b/file.txt\n--- a/file.txt\n++not header\n--not header"
    # Only ++not header and --not header should be counted
    codeflash_output = get_diff_lines_count(diff)

def test_blank_lines_between_diff_lines():
    # Test blank lines in between diff lines
    diff = "+added\n\n-removed\n\n"
    codeflash_output = get_diff_lines_count(diff)

def test_trailing_newline():
    # Test input with a trailing newline
    diff = "+added\n-removed\n"
    codeflash_output = get_diff_lines_count(diff)

def test_only_newlines():
    # Test input with only newline characters
    diff = "\n\n"
    codeflash_output = get_diff_lines_count(diff)

def test_single_character_lines():
    # Test lines that are only a single + or - character
    diff = "+\n-\n"
    codeflash_output = get_diff_lines_count(diff)

def test_diff_with_tabs_and_whitespace():
    # Test lines with tabs and whitespace after +/-
    diff = "+\tadded with tab\n-   removed with spaces"
    codeflash_output = get_diff_lines_count(diff)

def test_long_line_with_plus_minus_inside():
    # Test a long line that has + or - inside but not at the start
    diff = "context line + not diff\ncontext line - not diff"
    codeflash_output = get_diff_lines_count(diff)

def test_unicode_characters_in_diff():
    # Test diff lines containing unicode characters
    diff = "+üñîçødê added\n-删除的行"
    codeflash_output = get_diff_lines_count(diff)

def test_diff_with_carriage_return():
    # Test lines ending with \r\n (Windows line endings)
    diff = "+added line\r\n-removed line\r\n context\r\n"
    # Split on '\n' will still work
    codeflash_output = get_diff_lines_count(diff)

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

def test_large_number_of_diff_lines():
    # Test with a large number of added and removed lines (500 each)
    added = ["+added line {}".format(i) for i in range(500)]
    removed = ["-removed line {}".format(i) for i in range(500)]
    diff = "\n".join(added + removed)
    codeflash_output = get_diff_lines_count(diff)

def test_large_mixed_diff():
    # Test with a mix of diff, context, and header lines (total < 1000 lines)
    lines = []
    for i in range(300):
        lines.append("+added {}".format(i))
        lines.append(" context {}".format(i))
        lines.append("-removed {}".format(i))
        if i % 50 == 0:
            lines.append("--- a/file{}.txt".format(i))
            lines.append("+++ b/file{}.txt".format(i))
    diff = "\n".join(lines)
    # Only + and - lines (not headers) should count
    codeflash_output = get_diff_lines_count(diff)

def test_large_diff_with_headers_only():
    # Test with many header lines, but no actual diff lines
    headers = []
    for i in range(400):
        headers.append("--- a/file{}.txt".format(i))
        headers.append("+++ b/file{}.txt".format(i))
    diff = "\n".join(headers)
    codeflash_output = get_diff_lines_count(diff)

def test_large_diff_with_varied_line_starts():
    # Test with lines starting with +, -, ++, --, +++, ---, and context
    lines = []
    for i in range(150):
        lines.append("+added {}".format(i))
        lines.append("-removed {}".format(i))
        lines.append("++double plus {}".format(i))
        lines.append("--double minus {}".format(i))
        lines.append("+++triple plus {}".format(i))
        lines.append("---triple minus {}".format(i))
        lines.append(" context {}".format(i))
    diff = "\n".join(lines)
    # +, -, ++, -- all count (not +++ or ---)
    # 4 diff lines per iteration * 150 = 600
    codeflash_output = get_diff_lines_count(diff)

def test_diff_with_maximum_length_lines():
    # Test with very long lines (to check for performance issues)
    long_line = "+" + "a" * 1000
    diff = "\n".join([long_line for _ in range(500)])
    codeflash_output = get_diff_lines_count(diff)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from codeflash.code_utils.formatter import get_diff_lines_count

def test_get_diff_lines_count():
    get_diff_lines_count('')

To edit these changes git checkout codeflash/optimize-pr274-2025-06-03T21.47.40 and push.