⚡️ Speed up function indent by 5%

[codeflash-ai]

📄 5% (0.05x) speedup for indent in pandas/util/_decorators.py

⏱️ Runtime : 202 microseconds → 192 microseconds (best of 250 runs)

📝 Explanation and details

The optimization improves the indent function through two key changes that reduce computational overhead:

1. Efficient string concatenation: Replaced the list construction "".join(["\n"] + [" "] * indents) with direct string concatenation '\n' + " " * indents. This eliminates the overhead of creating an intermediate list and reduces memory allocations.

2. Early return for single-line strings: Added a check if "\n" not in text: return text to bypass the expensive split("\n") and join() operations when the input contains no newlines. Single-line strings can be returned immediately without any processing.

Why this leads to speedup: The original code always performed string splitting and joining operations regardless of input complexity. The optimization avoids these operations for the common case of single-line strings and uses more efficient string operations for multi-line cases.

Performance impact by use case:

• Single-line strings see dramatic improvements (32-69% faster) because they skip split/join entirely
• Multi-line strings show moderate gains (1-22% faster) from more efficient string concatenation
• Large inputs benefit from reduced memory pressure and fewer temporary objects

Context relevance: The function is used in pandas' decorator infrastructure (_decorators.py), particularly for formatting addendum text in docstring decorators. Given that docstring formatting is likely called during module initialization or help text generation, even small improvements can accumulate across pandas' large codebase.

The optimization is particularly effective for the common case where addendum text is a single line, which appears to be frequent based on the test results showing the highest speedups for single-line inputs.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

# imports
from pandas.util._decorators import indent

# unit tests

# === Basic Test Cases ===


def test_indent_single_line_default_indent():
    # Single line string, default indent (1)
    codeflash_output = indent("Hello")  # 1.22μs -> 764ns (59.8% faster)


def test_indent_single_line_custom_indent():
    # Single line string, custom indent (2)
    codeflash_output = indent("Hello", indents=2)  # 1.55μs -> 1.17μs (32.3% faster)


def test_indent_multi_line_default_indent():
    # Multi-line string, default indent
    text = "Hello\nWorld"
    expected = "    Hello\n    World"
    codeflash_output = indent(text)  # 1.35μs -> 1.20μs (12.8% faster)


def test_indent_multi_line_custom_indent():
    # Multi-line string, custom indent (3)
    text = "Hello\nWorld"
    expected = "            Hello\n            World"
    codeflash_output = indent(text, indents=3)  # 1.68μs -> 1.57μs (6.82% faster)


def test_indent_empty_string():
    # Empty string should return empty string
    codeflash_output = indent("")  # 312ns -> 288ns (8.33% faster)


def test_indent_none_input():
    # None input should return empty string
    codeflash_output = indent(None)  # 311ns -> 291ns (6.87% faster)


def test_indent_zero_indent():
    # Zero indent should not add spaces, just newlines
    text = "Hello\nWorld"
    expected = "\nHello\nWorld"
    codeflash_output = indent(text, indents=0)  # 1.71μs -> 1.56μs (9.28% faster)


# === Edge Test Cases ===


def test_indent_string_with_leading_trailing_newlines():
    # Leading/trailing newlines should be preserved and indented
    text = "\nHello\nWorld\n"
    expected = "    \n    Hello\n    World\n    "
    codeflash_output = indent(text)  # 1.64μs -> 1.37μs (19.8% faster)


def test_indent_string_with_multiple_consecutive_newlines():
    # Multiple consecutive newlines should be indented as empty lines
    text = "Hello\n\nWorld"
    expected = "    Hello\n    \n    World"
    codeflash_output = indent(text)  # 1.47μs -> 1.33μs (10.1% faster)


def test_indent_string_with_tabs_and_spaces():
    # String containing tabs and spaces should be preserved
    text = "\tHello \n  World"
    expected = "    \tHello \n      World"
    codeflash_output = indent(text)  # 1.37μs -> 1.23μs (11.1% faster)


def test_indent_string_with_only_newlines():
    # String with only newlines should produce indented empty lines
    text = "\n\n"
    expected = "    \n    \n    "
    codeflash_output = indent(text)  # 1.45μs -> 1.25μs (16.1% faster)


def test_indent_negative_indent():
    # Negative indent should still add just a newline (since ["    "] * -1 == [])
    text = "Hello\nWorld"
    expected = "\nHello\nWorld"
    codeflash_output = indent(text, indents=-1)  # 1.63μs -> 1.53μs (6.41% faster)


def test_indent_non_string_input_int():
    # Non-string input (int) should return empty string
    codeflash_output = indent(123)  # 527ns -> 505ns (4.36% faster)


def test_indent_non_string_input_list():
    # Non-string input (list) should return empty string
    codeflash_output = indent(["Hello", "World"])  # 468ns -> 449ns (4.23% faster)


def test_indent_unicode_and_non_ascii():
    # Unicode and non-ASCII characters should be preserved
    text = "你好\n世界"
    expected = "    你好\n    世界"
    codeflash_output = indent(text)  # 2.32μs -> 2.10μs (10.7% faster)


def test_indent_large_indent_value():
    # Large indent value (e.g., 50) should produce 200 spaces
    text = "Hello"
    expected = "\n" + ("    " * 50) + "Hello"
    codeflash_output = indent(text, indents=50)  # 2.17μs -> 1.28μs (69.8% faster)


def test_indent_string_with_no_newlines():
    # String with no newlines should be indented once
    text = "SingleLine"
    expected = "    SingleLine"
    codeflash_output = indent(text)  # 1.27μs -> 799ns (58.7% faster)


# === Large Scale Test Cases ===


def test_indent_long_single_line():
    # Very long single line string (1000 chars)
    text = "a" * 1000
    expected = "    " + "a" * 1000
    codeflash_output = indent(text)  # 1.44μs -> 918ns (56.5% faster)


def test_indent_many_lines():
    # Many lines (1000 lines)
    lines = [f"line{i}" for i in range(1000)]
    text = "\n".join(lines)
    expected = "\n".join("    " + line for line in lines)
    codeflash_output = indent(text)  # 21.4μs -> 20.9μs (2.08% faster)


def test_indent_many_lines_large_indent():
    # Many lines (500 lines), large indent (10)
    lines = [f"line{i}" for i in range(500)]
    text = "\n".join(lines)
    prefix = "    " * 10
    expected = "\n".join(prefix + line for line in lines)
    codeflash_output = indent(text, indents=10)  # 12.8μs -> 12.7μs (1.37% faster)


def test_indent_large_text_with_newlines_and_spaces():
    # Large text with mixture of lines, newlines, and spaces
    lines = ["   " + "A" * 50 for _ in range(300)]
    text = "\n".join(lines)
    expected = "\n".join("    " + line for line in lines)
    codeflash_output = indent(text)  # 11.6μs -> 11.7μs (1.10% slower)


def test_indent_performance_reasonable_time():
    # Test that indent runs in reasonable time for 1000 lines (no assertion, just should not hang)
    lines = ["line" + str(i) for i in range(1000)]
    text = "\n".join(lines)
    codeflash_output = indent(text)
    result = codeflash_output  # 24.6μs -> 24.8μs (0.735% slower)


# === Additional Edge Cases ===


def test_indent_with_empty_lines_and_content():
    # Mix of empty lines and content
    text = "\nHello\n\nWorld\n"
    expected = "    \n    Hello\n    \n    World\n    "
    codeflash_output = indent(text)  # 1.66μs -> 1.45μs (14.1% faster)


def test_indent_with_special_characters():
    # Special characters should be preserved
    text = "!@#$%^&*()\n[]{};':\",.<>/?"
    expected = "    !@#$%^&*()\n    []{};':\",.<>/?"
    codeflash_output = indent(text)  # 1.32μs -> 1.22μs (8.09% faster)


def test_indent_with_mixed_line_endings():
    # Handles mixed line endings (\n and \r\n)
    text = "Hello\r\nWorld\nTest"
    # The function splits only on '\n', so '\r' remains attached to 'Hello'
    expected = "    Hello\r\n    World\n    Test"
    codeflash_output = indent(text)  # 1.45μs -> 1.28μs (12.8% faster)


# 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 pandas.util._decorators import indent

# unit tests

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


def test_indent_single_line_default_indent():
    # Single line, default indent (1)
    codeflash_output = indent("hello world")  # 1.33μs -> 872ns (53.0% faster)


def test_indent_single_line_custom_indent():
    # Single line, custom indent (3)
    codeflash_output = indent(
        "hello world", indents=3
    )  # 1.69μs -> 1.23μs (37.2% faster)


def test_indent_multi_line_default_indent():
    # Multi-line string, default indent
    input_text = "line1\nline2\nline3"
    expected = "\n    line1\n    line2\n    line3"
    codeflash_output = indent(input_text)  # 1.47μs -> 1.31μs (11.8% faster)


def test_indent_multi_line_custom_indent():
    # Multi-line string, custom indent
    input_text = "a\nb\nc"
    expected = "\n        a\n        b\n        c"
    codeflash_output = indent(input_text, indents=2)  # 1.78μs -> 1.70μs (4.96% faster)


def test_indent_empty_string():
    # Empty string should return ""
    codeflash_output = indent("")  # 303ns -> 290ns (4.48% faster)


def test_indent_none_input():
    # None input should return ""
    codeflash_output = indent(None)  # 299ns -> 301ns (0.664% slower)


def test_indent_zero_indent():
    # Zero indents should produce no spaces, only newline
    input_text = "foo\nbar"
    expected = "\nfoo\nbar"
    codeflash_output = indent(input_text, indents=0)  # 1.73μs -> 1.63μs (5.76% faster)


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


def test_indent_negative_indent():
    # Negative indents should produce fewer than zero spaces (which is just newline)
    input_text = "x\ny"
    expected = "\nx\ny"
    codeflash_output = indent(input_text, indents=-2)  # 1.65μs -> 1.53μs (7.99% faster)


def test_indent_non_string_input_int():
    # Non-string input (int) should return ""
    codeflash_output = indent(123)  # 526ns -> 510ns (3.14% faster)


def test_indent_non_string_input_list():
    # Non-string input (list) should return ""
    codeflash_output = indent(["a", "b", "c"])  # 454ns -> 453ns (0.221% faster)


def test_indent_string_with_trailing_newline():
    # Trailing newline should produce extra indented empty line
    input_text = "foo\nbar\n"
    expected = "\n    foo\n    bar\n    "
    codeflash_output = indent(input_text)  # 1.77μs -> 1.45μs (22.7% faster)


def test_indent_string_with_leading_newline():
    # Leading newline should produce an indented empty line at start
    input_text = "\nfoo\nbar"
    expected = "\n    \n    foo\n    bar"
    codeflash_output = indent(input_text)  # 1.51μs -> 1.34μs (12.4% faster)


def test_indent_string_with_multiple_consecutive_newlines():
    # Multiple consecutive newlines should produce multiple indented blank lines
    input_text = "a\n\nb"
    expected = "\n    a\n    \n    b"
    codeflash_output = indent(input_text)  # 1.43μs -> 1.25μs (14.5% faster)


def test_indent_string_with_only_newlines():
    # Only newlines should produce indented empty lines
    input_text = "\n\n"
    expected = "\n    \n    \n    "
    codeflash_output = indent(input_text)  # 1.44μs -> 1.23μs (17.2% faster)


def test_indent_string_with_spaces_only():
    # String with only spaces should be indented
    input_text = "   "
    expected = "\n       "
    codeflash_output = indent(input_text)  # 1.20μs -> 717ns (67.2% faster)


def test_indent_string_with_tabs_and_spaces():
    # String with tabs and spaces
    input_text = "\tfoo \n bar\t"
    expected = "\n    \tfoo \n    bar\t"
    codeflash_output = indent(input_text)  # 1.34μs -> 1.26μs (6.77% faster)


def test_indent_string_with_unicode_characters():
    # String containing unicode characters
    input_text = "你好\n世界"
    expected = "\n    你好\n    世界"
    codeflash_output = indent(input_text)  # 2.08μs -> 2.05μs (1.81% faster)


def test_indent_string_with_escape_characters():
    # String with escape characters
    input_text = "foo\\nbar"
    expected = "\n    foo\\nbar"
    codeflash_output = indent(input_text)  # 1.17μs -> 737ns (58.5% faster)


def test_indent_indents_is_none():
    # indents=None should raise a TypeError
    with pytest.raises(TypeError):
        indent("abc", indents=None)  # 1.74μs -> 1.59μs (9.38% faster)


def test_indent_indents_is_float():
    # indents as float should raise TypeError (since multiplying list by float is invalid)
    with pytest.raises(TypeError):
        indent("abc", indents=2.5)  # 1.84μs -> 1.61μs (14.7% faster)


def test_indent_indents_is_str():
    # indents as string should raise TypeError
    with pytest.raises(TypeError):
        indent("abc", indents="3")  # 1.65μs -> 1.46μs (13.3% faster)


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


def test_indent_large_multiline_string():
    # Large string with 1000 lines, default indent
    input_text = "\n".join([f"line{i}" for i in range(1000)])
    expected = "\n    " + "\n    ".join([f"line{i}" for i in range(1000)])
    codeflash_output = indent(input_text)  # 21.3μs -> 21.2μs (0.482% faster)


def test_indent_large_multiline_string_custom_indent():
    # Large string with 500 lines, custom indent
    input_text = "\n".join([f"item{i}" for i in range(500)])
    expected = "\n        " + "\n        ".join([f"item{i}" for i in range(500)])
    codeflash_output = indent(input_text, indents=2)  # 12.4μs -> 12.2μs (1.88% faster)


def test_indent_large_single_line():
    # Very long single line string
    input_text = "x" * 1000
    expected = "\n    " + "x" * 1000
    codeflash_output = indent(input_text)  # 1.52μs -> 891ns (71.2% faster)


def test_indent_large_string_with_many_newlines_and_blanks():
    # Large string with many blank lines mixed in
    input_text = "\n".join(["" if i % 10 == 0 else f"val{i}" for i in range(1000)])
    expected = "\n    " + "\n    ".join(
        ["" if i % 10 == 0 else f"val{i}" for i in range(1000)]
    )
    codeflash_output = indent(input_text)  # 20.4μs -> 20.1μs (1.61% faster)


def test_indent_performance_large_input(monkeypatch):
    # Large input should not take excessive time (smoke test)
    import time

    input_text = "\n".join([str(i) for i in range(1000)])
    start = time.time()
    codeflash_output = indent(input_text)
    result = codeflash_output  # 19.7μs -> 19.4μs (1.48% faster)
    duration = time.time() - start
    # Result should be correct
    expected = "\n    " + "\n    ".join([str(i) for i in range(1000)])


# 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-indent-miihwnmz and push.