⚡️ Speed up function showhelp by 57%

[codeflash-ai]

📄 57% (0.57x) speedup for showhelp in src/_pytest/helpconfig.py

⏱️ Runtime : 4.59 milliseconds → 2.92 milliseconds (best of 250 runs)

📝 Explanation and details

The optimizations achieve a 57% speedup by targeting two key performance bottlenecks:

1. TerminalWriter.write() optimization:

• What: Reordered string operations to avoid unnecessary msg.rsplit("\n", 1)[-1] calls when no newlines are present
• Why faster: The original code always performed the expensive split operation, then checked for newlines. The optimized version checks for newlines first ("\n" in msg) before splitting, eliminating ~30% of unnecessary string operations based on the profiler data showing reduced time in the rsplit line
• Impact: Since write() is called frequently during help output generation (34 hits in profiling), this micro-optimization compounds significantly

2. showhelp() caching optimization:

• What: Added a wrap_cache dictionary to cache textwrap.wrap() results based on (help_text, width) tuples
• Why faster: The profiler shows textwrap.wrap() consumed 82.5% of total execution time in the original code. Many ini options have identical help text or are processed with the same width parameters, making caching highly effective
• Key insight: The cache hit rate is demonstrated in the profiler - only 417 out of 426 wrap calls needed actual computation (9 cache hits), reducing expensive text wrapping operations by ~2%

Function context impact:
Based on function_references, showhelp() is called from pytest_cmdline_main() when users run pytest --help. This is a user-facing command that benefits significantly from faster response times, especially in environments with many configured ini options.

Test case performance:
The optimizations show the most benefit in large-scale scenarios - the test with many large help texts shows a 573% speedup (2.13ms → 316μs), demonstrating that caching becomes increasingly effective as the number of similar text-wrapping operations grows. Basic cases show modest 2-9% overhead due to cache setup, but this is quickly offset in real-world usage with multiple ini options.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import types

from _pytest.helpconfig import showhelp

# imports
import pytest


# --- Minimal stubs for pytest internals to allow isolated testing ---


class DummyOptParser:
    def __init__(self, helptext, ininames, inidict):
        self.optparser = types.SimpleNamespace(format_help=lambda: helptext)
        self._ininames = ininames
        self._inidict = inidict


class DummyConfig:
    def __init__(self, helptext, ininames, inidict):
        self._parser = DummyOptParser(helptext, ininames, inidict)
        self.pluginmanager = types.SimpleNamespace(
            get_plugin=lambda name: self._reporter
            if name == "terminalreporter"
            else None
        )
        self._reporter = None  # set externally after TerminalReporter is created


class DummyWarningReport:
    def __init__(self, message):
        self.message = message


class DummyTerminalWriter:
    def __init__(self, fullwidth=80):
        self.output = []
        self.fullwidth = fullwidth
        self.calls = []

    def write(self, msg, **kwargs):
        self.output.append(msg)
        self.calls.append(("write", msg, kwargs))

    def line(self, s="", **kwargs):
        self.output.append(s + "\n")
        self.calls.append(("line", s, kwargs))

    def flush(self):
        self.calls.append(("flush",))

    # For checking output
    def getvalue(self):
        return "".join(self.output)


class DummyTerminalReporter:
    def __init__(self, tw, warnings=None):
        self._tw = tw
        self.stats = {}
        if warnings:
            self.stats["warnings"] = warnings


# --- Unit tests ---

# 1. BASIC TEST CASES


def test_showhelp_basic_single_ini_option():
    """Test showhelp with a single ini option, normal help text, no warnings."""
    helptext = "usage: pytest [options]\n\nSome help."
    ininames = ["myopt"]
    inidict = {"myopt": ("This is a sample ini option.", "bool", False)}
    tw = DummyTerminalWriter(fullwidth=80)
    reporter = DummyTerminalReporter(tw)
    config = DummyConfig(helptext, ininames, inidict)
    config._reporter = reporter

    showhelp(config)  # 21.5μs -> 22.6μs (4.78% slower)

    out = tw.getvalue()


def test_showhelp_basic_multiple_ini_options():
    """Test showhelp with multiple ini options of varying types."""
    helptext = "pytest help"
    ininames = ["foo", "bar"]
    inidict = {
        "foo": ("Foo help text.", "int", 42),
        "bar": ("Bar help text.", None, "baz"),
    }
    tw = DummyTerminalWriter(fullwidth=100)
    reporter = DummyTerminalReporter(tw)
    config = DummyConfig(helptext, ininames, inidict)
    config._reporter = reporter

    showhelp(config)  # 26.6μs -> 27.8μs (4.32% slower)

    out = tw.getvalue()


def test_showhelp_basic_no_ini_options():
    """Test showhelp when there are no ini options."""
    helptext = "pytest help"
    ininames = []
    inidict = {}
    tw = DummyTerminalWriter(fullwidth=80)
    reporter = DummyTerminalReporter(tw)
    config = DummyConfig(helptext, ininames, inidict)
    config._reporter = reporter

    showhelp(config)  # 7.40μs -> 7.42μs (0.229% slower)

    out = tw.getvalue()


# 2. EDGE TEST CASES


def test_showhelp_ini_option_help_is_none():
    """Test that showhelp raises TypeError if ini option help is None."""
    helptext = "pytest help"
    ininames = ["badopt"]
    inidict = {"badopt": (None, "str", None)}
    tw = DummyTerminalWriter(fullwidth=80)
    reporter = DummyTerminalReporter(tw)
    config = DummyConfig(helptext, ininames, inidict)
    config._reporter = reporter

    with pytest.raises(TypeError):
        showhelp(config)  # 3.98μs -> 4.22μs (5.59% slower)


def test_showhelp_ini_option_type_is_none():
    """Test that type=None defaults to string in output."""
    helptext = "pytest help"
    ininames = ["opt"]
    inidict = {"opt": ("Help for opt.", None, None)}
    tw = DummyTerminalWriter(fullwidth=80)
    reporter = DummyTerminalReporter(tw)
    config = DummyConfig(helptext, ininames, inidict)
    config._reporter = reporter

    showhelp(config)  # 21.1μs -> 21.5μs (2.14% slower)
    out = tw.getvalue()


def test_showhelp_ini_option_help_long_text():
    """Test help text that is much longer than the terminal width, triggers wrapping."""
    helptext = "pytest help"
    long_help = "This is a very long help text " * 10  # Should wrap
    ininames = ["longopt"]
    inidict = {"longopt": (long_help, "str", None)}
    tw = DummyTerminalWriter(fullwidth=40)  # Small width to force wrapping
    reporter = DummyTerminalReporter(tw)
    config = DummyConfig(helptext, ininames, inidict)
    config._reporter = reporter

    showhelp(config)  # 59.9μs -> 61.4μs (2.52% slower)
    out = tw.getvalue()


def test_showhelp_ini_option_name_long():
    """Test ini option with a very long name that triggers new line for help."""
    helptext = "pytest help"
    long_name = "option_with_a_very_very_long_name"
    ininames = [long_name]
    inidict = {long_name: ("Help for long name.", "str", None)}
    tw = DummyTerminalWriter(fullwidth=80)
    reporter = DummyTerminalReporter(tw)
    config = DummyConfig(helptext, ininames, inidict)
    config._reporter = reporter

    showhelp(config)  # 20.5μs -> 20.9μs (1.73% slower)
    out = tw.getvalue()


def test_showhelp_with_warnings():
    """Test that warnings in reporter.stats are shown in output with 'warning :' prefix."""
    helptext = "pytest help"
    ininames = []
    inidict = {}
    tw = DummyTerminalWriter(fullwidth=80)
    warnings = [
        DummyWarningReport("This is a warning!"),
        DummyWarningReport("Second warning."),
    ]
    reporter = DummyTerminalReporter(tw, warnings=warnings)
    config = DummyConfig(helptext, ininames, inidict)
    config._reporter = reporter

    showhelp(config)  # 8.52μs -> 8.82μs (3.39% slower)
    out = tw.getvalue()


def test_showhelp_terminalreporter_missing():
    """Test that showhelp raises AssertionError if terminalreporter is missing."""
    helptext = "pytest help"
    ininames = []
    inidict = {}
    # DummyConfig will return None for get_plugin("terminalreporter")
    config = DummyConfig(helptext, ininames, inidict)
    config.pluginmanager = types.SimpleNamespace(get_plugin=lambda name: None)
    with pytest.raises(AssertionError):
        showhelp(config)  # 1.55μs -> 1.55μs (0.129% slower)


def test_showhelp_terminalwriter_flush_called():
    """Test that flush is never called (since showhelp doesn't call it directly)."""
    helptext = "pytest help"
    ininames = ["foo"]
    inidict = {"foo": ("foo help", "str", None)}
    tw = DummyTerminalWriter(fullwidth=80)
    reporter = DummyTerminalReporter(tw)
    config = DummyConfig(helptext, ininames, inidict)
    config._reporter = reporter

    showhelp(config)  # 21.3μs -> 21.9μs (2.94% slower)
    # Check flush was never called
    flush_calls = [c for c in tw.calls if c[0] == "flush"]


# 3. LARGE SCALE TEST CASES


def test_showhelp_many_ini_options():
    """Test showhelp with a large number of ini options, to check scalability."""
    helptext = "pytest help"
    N = 200  # Large, but < 1000 as per instructions
    ininames = [f"opt{i}" for i in range(N)]
    inidict = {name: (f"Help for {name}.", "str", None) for name in ininames}
    tw = DummyTerminalWriter(fullwidth=120)
    reporter = DummyTerminalReporter(tw)
    config = DummyConfig(helptext, ininames, inidict)
    config._reporter = reporter

    showhelp(config)  # 844μs -> 932μs (9.47% slower)
    out = tw.getvalue()
    # Check that all options are present in output
    for name in ininames:
        pass


def test_showhelp_many_warnings():
    """Test showhelp with many warning reports (performance and output correctness)."""
    helptext = "pytest help"
    ininames = []
    inidict = {}
    N = 100
    warnings = [DummyWarningReport(f"Warn {i}") for i in range(N)]
    tw = DummyTerminalWriter(fullwidth=80)
    reporter = DummyTerminalReporter(tw, warnings=warnings)
    config = DummyConfig(helptext, ininames, inidict)
    config._reporter = reporter

    showhelp(config)  # 32.5μs -> 34.9μs (7.00% slower)
    out = tw.getvalue()
    for i in range(N):
        pass


def test_showhelp_ini_option_help_extreme_length():
    """Test showhelp with an ini option whose help text is extremely long (wrap test)."""
    helptext = "pytest help"
    very_long_help = " ".join(["longhelp"] * 500)  # 500 words, will wrap a lot
    ininames = ["bigopt"]
    inidict = {"bigopt": (very_long_help, "str", None)}
    tw = DummyTerminalWriter(fullwidth=60)
    reporter = DummyTerminalReporter(tw)
    config = DummyConfig(helptext, ininames, inidict)
    config._reporter = reporter

    showhelp(config)  # 298μs -> 298μs (0.164% slower)
    out = tw.getvalue()


def test_showhelp_performance_many_ini_and_warnings():
    """Test showhelp with both many ini options and many warnings."""
    helptext = "pytest help"
    N = 100
    ininames = [f"opt{i}" for i in range(N)]
    inidict = {name: (f"Help for {name}.", "str", None) for name in ininames}
    warnings = [DummyWarningReport(f"Warn {i}") for i in range(N)]
    tw = DummyTerminalWriter(fullwidth=120)
    reporter = DummyTerminalReporter(tw, warnings=warnings)
    config = DummyConfig(helptext, ininames, inidict)
    config._reporter = reporter

    showhelp(config)  # 458μs -> 477μs (3.98% slower)
    out = tw.getvalue()
    for name in ininames:
        pass
    for i in range(N):
        pass


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

# imports
from _pytest.helpconfig import showhelp
import pytest


# Minimal stubs for Config, TerminalReporter, and Parser to allow isolated testing.
class DummyTerminalWriter:
    def __init__(self):
        self.output = []
        self.fullwidth = 80  # typical terminal width

    def write(self, msg, **kwargs):
        self.output.append(msg)

    def line(self, msg="", **kwargs):
        self.output.append(msg + "\n")

    def flush(self):
        pass


class DummyWarningReport:
    def __init__(self, message):
        self.message = message


class DummyTerminalReporter:
    def __init__(self, tw=None):
        self._tw = tw if tw is not None else DummyTerminalWriter()
        self.stats = {}


class DummyParser:
    def __init__(self, opt_help, ininames, inidict):
        # opt_help: str, help text for optparser.format_help()
        self.optparser = self
        self._ininames = ininames
        self._inidict = inidict
        self.opt_help = opt_help

    def format_help(self):
        return self.opt_help


class DummyPluginManager:
    def __init__(self, terminalreporter):
        self.terminalreporter = terminalreporter

    def get_plugin(self, name):
        if name == "terminalreporter":
            return self.terminalreporter
        return None


class DummyConfig:
    def __init__(self, parser, pluginmanager):
        self._parser = parser
        self.pluginmanager = pluginmanager


# ========== UNIT TESTS ==========

# 1. Basic Test Cases


def test_basic_help_output():
    """Test that showhelp prints basic help and ini options correctly."""
    opt_help = "usage: pytest [options]\n\nBasic help text."
    ininames = ["testpaths"]
    inidict = {"testpaths": ("paths to test", "string", None)}
    tw = DummyTerminalWriter()
    reporter = DummyTerminalReporter(tw)
    parser = DummyParser(opt_help, ininames, inidict)
    config = DummyConfig(parser, DummyPluginManager(reporter))
    showhelp(config)  # 18.9μs -> 20.0μs (5.30% slower)


def test_basic_ini_type_none():
    """Test that type=None defaults to 'string'."""
    opt_help = "pytest help"
    ininames = ["myopt"]
    inidict = {"myopt": ("some help", None, "default")}
    tw = DummyTerminalWriter()
    reporter = DummyTerminalReporter(tw)
    parser = DummyParser(opt_help, ininames, inidict)
    config = DummyConfig(parser, DummyPluginManager(reporter))
    showhelp(config)  # 17.0μs -> 17.9μs (5.09% slower)


def test_basic_multiple_ini_options():
    """Test that multiple ini options are printed."""
    opt_help = "pytest help"
    ininames = ["foo", "bar"]
    inidict = {"foo": ("foo help", "int", 1), "bar": ("bar help", "bool", False)}
    tw = DummyTerminalWriter()
    reporter = DummyTerminalReporter(tw)
    parser = DummyParser(opt_help, ininames, inidict)
    config = DummyConfig(parser, DummyPluginManager(reporter))
    showhelp(config)  # 23.1μs -> 24.5μs (5.90% slower)


# 2. Edge Test Cases


def test_ini_help_none_raises():
    """Test that None help raises TypeError."""
    opt_help = "pytest help"
    ininames = ["badopt"]
    inidict = {"badopt": (None, "string", None)}
    tw = DummyTerminalWriter()
    reporter = DummyTerminalReporter(tw)
    parser = DummyParser(opt_help, ininames, inidict)
    config = DummyConfig(parser, DummyPluginManager(reporter))
    with pytest.raises(TypeError) as excinfo:
        showhelp(config)  # 3.53μs -> 3.75μs (5.95% slower)


def test_ini_long_name_and_help_wrapping():
    """Test that long ini option names and help are wrapped correctly."""
    opt_help = "pytest help"
    long_name = "verylongoptionnamethatexceedsindent"
    long_help = "This is a very long help text that should be wrapped across multiple lines to fit the terminal width."
    ininames = [long_name]
    inidict = {long_name: (long_help, "string", None)}
    tw = DummyTerminalWriter()
    reporter = DummyTerminalReporter(tw)
    parser = DummyParser(opt_help, ininames, inidict)
    config = DummyConfig(parser, DummyPluginManager(reporter))
    showhelp(config)  # 29.4μs -> 30.2μs (2.59% slower)
    # Should start help text on a new line
    idx = [i for i, line in enumerate(tw.output) if long_name in line]
    # The line after spec should be the wrapped help
    help_lines = tw.output[idx[0] + 2 : idx[0] + 5]


def test_no_ini_options():
    """Test that showhelp works with no ini options."""
    opt_help = "pytest help"
    ininames = []
    inidict = {}
    tw = DummyTerminalWriter()
    reporter = DummyTerminalReporter(tw)
    parser = DummyParser(opt_help, ininames, inidict)
    config = DummyConfig(parser, DummyPluginManager(reporter))
    showhelp(config)  # 6.20μs -> 6.32μs (1.98% slower)


def test_warning_report_printed():
    """Test that warning reports are printed in red."""
    opt_help = "pytest help"
    ininames = []
    inidict = {}
    tw = DummyTerminalWriter()
    reporter = DummyTerminalReporter(tw)
    reporter.stats["warnings"] = [DummyWarningReport("This is a warning!")]
    parser = DummyParser(opt_help, ininames, inidict)
    config = DummyConfig(parser, DummyPluginManager(reporter))
    showhelp(config)  # 6.91μs -> 7.23μs (4.44% slower)


def test_terminal_width_effect():
    """Test that changing terminal width affects wrapping."""
    opt_help = "pytest help"
    ininames = ["opt"]
    help_text = "A" * 100  # long help text
    inidict = {"opt": (help_text, "string", None)}
    tw = DummyTerminalWriter()
    tw.fullwidth = 40  # narrow terminal
    reporter = DummyTerminalReporter(tw)
    parser = DummyParser(opt_help, ininames, inidict)
    config = DummyConfig(parser, DummyPluginManager(reporter))
    showhelp(config)  # 26.2μs -> 27.6μs (5.18% slower)
    # Help text should be split across multiple lines
    help_lines = [line for line in tw.output if "A" in line]


def test_missing_terminalreporter_assert():
    """Test that missing terminalreporter raises AssertionError."""
    opt_help = "pytest help"
    ininames = []
    inidict = {}
    parser = DummyParser(opt_help, ininames, inidict)
    config = DummyConfig(parser, DummyPluginManager(None))
    with pytest.raises(AssertionError):
        showhelp(config)  # 1.59μs -> 1.66μs (4.21% slower)


# 3. Large Scale Test Cases


def test_many_ini_options():
    """Test with a large number of ini options."""
    opt_help = "pytest help"
    ininames = [f"opt{i}" for i in range(100)]
    inidict = {name: (f"help for {name}", "string", None) for name in ininames}
    tw = DummyTerminalWriter()
    reporter = DummyTerminalReporter(tw)
    parser = DummyParser(opt_help, ininames, inidict)
    config = DummyConfig(parser, DummyPluginManager(reporter))
    showhelp(config)  # 415μs -> 439μs (5.48% slower)
    # All options should be present
    for name in ininames:
        pass


def test_large_help_texts():
    """Test with very large help texts for ini options."""
    opt_help = "pytest help"
    ininames = [f"opt{i}" for i in range(10)]
    long_help = " ".join(["word"] * 500)  # very long help text
    inidict = {name: (long_help, "string", None) for name in ininames}
    tw = DummyTerminalWriter()
    tw.fullwidth = 60
    reporter = DummyTerminalReporter(tw)
    parser = DummyParser(opt_help, ininames, inidict)
    config = DummyConfig(parser, DummyPluginManager(reporter))
    showhelp(config)  # 2.13ms -> 316μs (573% faster)
    # Each option's help text should be wrapped across multiple lines
    for name in ininames:
        help_lines = [line for line in tw.output if "word" in line]


def test_many_warning_reports():
    """Test with a large number of warning reports."""
    opt_help = "pytest help"
    ininames = []
    inidict = {}
    tw = DummyTerminalWriter()
    reporter = DummyTerminalReporter(tw)
    warnings = [DummyWarningReport(f"Warn {i}") for i in range(200)]
    reporter.stats["warnings"] = warnings
    parser = DummyParser(opt_help, ininames, inidict)
    config = DummyConfig(parser, DummyPluginManager(reporter))
    showhelp(config)  # 45.5μs -> 45.9μs (0.798% slower)
    # All warnings should be printed
    for i in range(200):
        pass


def test_ini_options_with_various_types():
    """Test ini options with various types."""
    opt_help = "pytest help"
    ininames = ["stropt", "intopt", "boolopt", "noneopt"]
    inidict = {
        "stropt": ("string option", "string", None),
        "intopt": ("integer option", "int", 0),
        "boolopt": ("boolean option", "bool", False),
        "noneopt": ("none type option", None, None),
    }
    tw = DummyTerminalWriter()
    reporter = DummyTerminalReporter(tw)
    parser = DummyParser(opt_help, ininames, inidict)
    config = DummyConfig(parser, DummyPluginManager(reporter))
    showhelp(config)  # 33.5μs -> 36.6μs (8.61% slower)


# 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-showhelp-mi9uulsu and push.