⚡️ Speed up function _get_mode_intro_message by 31%

[codeflash-ai]

📄 31% (0.31x) speedup for _get_mode_intro_message in marimo/_server/ai/prompts.py

⏱️ Runtime : 167 microseconds → 127 microseconds (best of 84 runs)

📝 Explanation and details

The optimization replaces runtime string concatenation with pre-constructed module-level constants. In the original code, each function call performed string formatting (f"{base_intro}") and concatenated multiple string literals at runtime. The optimized version eliminates this overhead by pre-building the complete intro messages as module constants _MANUAL_INTRO and _ASK_INTRO.

Key changes:

• Removed the base_intro variable and f-string formatting operations
• Pre-constructed complete messages as module-level constants
• Function now simply returns the appropriate pre-built string

Why this is faster:
String concatenation and formatting in Python involves memory allocation and copying operations at runtime. By moving this work to module import time (which happens once), each function call now only performs a simple constant lookup and return, eliminating the repeated string operations.

Performance characteristics:
The optimization shows consistent 30-80% speedup across all test cases, with particularly strong gains on repeated calls (up to 79% faster). This makes it especially beneficial for high-frequency usage patterns where the same mode is requested multiple times, as evidenced by the large batch tests showing 30-31% improvements even across 500 calls.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

# imports
import pytest  # used for our unit tests
from marimo._server.ai.prompts import _get_mode_intro_message

# function to test
# Copyright 2024 Marimo. All rights reserved.


# Simulate the CopilotMode type as a str alias for testing purposes
CopilotMode = str
from marimo._server.ai.prompts import _get_mode_intro_message

# unit tests

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

def test_manual_mode_returns_expected_message():
    """Test that 'manual' mode returns the correct intro message."""
    codeflash_output = _get_mode_intro_message("manual"); result = codeflash_output # 450ns -> 322ns (39.8% faster)

def test_ask_mode_returns_expected_message():
    """Test that 'ask' mode returns the correct intro message."""
    codeflash_output = _get_mode_intro_message("ask"); result = codeflash_output # 552ns -> 353ns (56.4% faster)

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

@pytest.mark.parametrize("invalid_mode", [
    "",  # empty string
    "MANUAL",  # wrong case
    "Ask",     # wrong case
    "auto",    # unsupported mode
    "manual ", # trailing whitespace
    " ask",    # leading whitespace
    "manual\n",# newline
    None,      # NoneType
    123,       # integer
    [],        # list
    {},        # dict
    object(),  # arbitrary object
])
def test_invalid_modes_raise_value_error(invalid_mode):
    """Test that invalid modes raise a ValueError."""
    with pytest.raises(ValueError):
        _get_mode_intro_message(invalid_mode)

def test_manual_mode_is_case_sensitive():
    """Test that 'manual' mode is case-sensitive."""
    with pytest.raises(ValueError):
        _get_mode_intro_message("MANUAL")
    with pytest.raises(ValueError):
        _get_mode_intro_message("Manual")

def test_ask_mode_is_case_sensitive():
    """Test that 'ask' mode is case-sensitive."""
    with pytest.raises(ValueError):
        _get_mode_intro_message("ASK")
    with pytest.raises(ValueError):
        _get_mode_intro_message("Ask")

def test_manual_mode_exact_output():
    """Test the exact output for 'manual' mode (regression test)."""
    expected = (
        "You are Marimo Copilot, an AI assistant integrated into the marimo notebook code editor.\n"
        "Your primary function is to help users create, analyze, and improve data science notebooks using marimo's reactive programming model.\n"
        "## Capabilities\n"
        "- Answer questions and provide guidance using only your internal knowledge and the notebook context provided by the user.\n"
        "\n"
        "## Limitations\n"
        "- You do NOT have access to any external tools, plugins, or APIs.\n"
        "- You may not perform any actions beyond generating text and code suggestions.\n"
    )
    codeflash_output = _get_mode_intro_message("manual"); actual = codeflash_output # 649ns -> 410ns (58.3% faster)

def test_ask_mode_exact_output():
    """Test the exact output for 'ask' mode (regression test)."""
    expected = (
        "You are Marimo Copilot, an AI assistant integrated into the marimo notebook code editor.\n"
        "Your primary function is to help users create, analyze, and improve data science notebooks using marimo's reactive programming model.\n"
        "## Capabilities\n"
        "- You can use a set of read-only tools to gather additional context from the notebook or environment (e.g., searching code, summarizing data, or reading documentation).\n"
        "- You may use these tools ONLY to gather information, not to modify code or state.\n"
        "\n"
        "## Limitations\n"
        "- All tool use is strictly read-only. You may not perform write, edit, or execution actions.\n"
        "- You must always explain to the user why you are using a tool before invoking it.\n"
    )
    codeflash_output = _get_mode_intro_message("ask"); actual = codeflash_output # 574ns -> 383ns (49.9% faster)

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


def test_performance_on_large_batch_of_valid_and_invalid_modes():
    """Test function's performance and correctness on a large batch of mixed modes."""
    # 500 valid, 500 invalid
    valid_modes = ["manual", "ask"] * 250
    invalid_modes = [f"badmode_{i}" for i in range(500)]
    modes = valid_modes + invalid_modes
    results = []
    for mode in modes:
        if mode in ("manual", "ask"):
            # Should not raise
            results.append(_get_mode_intro_message(mode))
        else:
            with pytest.raises(ValueError):
                _get_mode_intro_message(mode)

def test_no_side_effects_on_repeated_calls():
    """Test that repeated calls with the same mode yield identical results (idempotency, statelessness)."""
    codeflash_output = _get_mode_intro_message("manual"); manual_msg1 = codeflash_output # 617ns -> 426ns (44.8% faster)
    codeflash_output = _get_mode_intro_message("manual"); manual_msg2 = codeflash_output # 224ns -> 152ns (47.4% faster)
    codeflash_output = _get_mode_intro_message("ask"); ask_msg1 = codeflash_output # 303ns -> 207ns (46.4% faster)
    codeflash_output = _get_mode_intro_message("ask"); ask_msg2 = codeflash_output # 211ns -> 125ns (68.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 marimo._server.ai.prompts import _get_mode_intro_message

# function to test
# Copyright 2024 Marimo. All rights reserved.


# Simulate the CopilotMode type for testing purposes
CopilotMode = str
from marimo._server.ai.prompts import _get_mode_intro_message

# unit tests

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

def test_manual_mode_returns_expected_message():
    # Test that manual mode returns the correct intro message
    codeflash_output = _get_mode_intro_message("manual"); result = codeflash_output # 498ns -> 370ns (34.6% faster)

def test_ask_mode_returns_expected_message():
    # Test that ask mode returns the correct intro message
    codeflash_output = _get_mode_intro_message("ask"); result = codeflash_output # 570ns -> 369ns (54.5% faster)

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

@pytest.mark.parametrize("invalid_mode", [
    "",  # empty string
    "MANUAL",  # case sensitivity
    "Ask",     # case sensitivity
    "auto",    # unsupported mode
    "random",  # arbitrary string
    None,      # NoneType
    123,       # integer
    [],        # list
    {},        # dict
])
def test_invalid_mode_raises_value_error(invalid_mode):
    # Test that invalid modes raise a ValueError
    with pytest.raises(ValueError):
        _get_mode_intro_message(invalid_mode)

def test_manual_mode_is_case_sensitive():
    # "MANUAL" should not be recognized (case sensitive)
    with pytest.raises(ValueError):
        _get_mode_intro_message("MANUAL")

def test_ask_mode_is_case_sensitive():
    # "ASK" should not be recognized (case sensitive)
    with pytest.raises(ValueError):
        _get_mode_intro_message("ASK")

def test_mode_with_leading_trailing_spaces():
    # Modes with spaces should not be recognized
    with pytest.raises(ValueError):
        _get_mode_intro_message(" manual ")
    with pytest.raises(ValueError):
        _get_mode_intro_message("ask ")

def test_mode_with_similar_names():
    # Modes that are similar but not exact should not be recognized
    with pytest.raises(ValueError):
        _get_mode_intro_message("manuall")
    with pytest.raises(ValueError):
        _get_mode_intro_message("asks")

def test_mode_with_unicode_characters():
    # Unicode in mode should not be accepted
    with pytest.raises(ValueError):
        _get_mode_intro_message("manuål")
    with pytest.raises(ValueError):
        _get_mode_intro_message("ásk")

def test_mode_with_numeric_string():
    # Numeric string is not a valid mode
    with pytest.raises(ValueError):
        _get_mode_intro_message("123")

def test_mode_with_special_characters():
    # Special characters are not valid modes
    with pytest.raises(ValueError):
        _get_mode_intro_message("@ask!")
    with pytest.raises(ValueError):
        _get_mode_intro_message("manual#")

def test_mode_with_whitespace_only():
    # Whitespace only string is not a valid mode
    with pytest.raises(ValueError):
        _get_mode_intro_message("   ")

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

def test_large_batch_of_manual_modes():
    # Test performance and determinism with a large batch of 'manual' mode calls
    for _ in range(500):
        codeflash_output = _get_mode_intro_message("manual"); result = codeflash_output # 76.7μs -> 58.5μs (31.1% faster)

def test_large_batch_of_ask_modes():
    # Test performance and determinism with a large batch of 'ask' mode calls
    for _ in range(500):
        codeflash_output = _get_mode_intro_message("ask"); result = codeflash_output # 82.5μs -> 63.5μs (30.0% faster)


def test_unique_output_for_each_mode():
    # Ensure that the output for 'manual' and 'ask' modes are unique and not identical
    codeflash_output = _get_mode_intro_message("manual"); manual_msg = codeflash_output # 661ns -> 419ns (57.8% faster)
    codeflash_output = _get_mode_intro_message("ask"); ask_msg = codeflash_output # 371ns -> 236ns (57.2% faster)

def test_message_length_manual_and_ask():
    # Check that message lengths are within expected bounds (not truncated or excessively long)
    codeflash_output = _get_mode_intro_message("manual"); manual_msg = codeflash_output # 526ns -> 306ns (71.9% faster)
    codeflash_output = _get_mode_intro_message("ask"); ask_msg = codeflash_output # 341ns -> 211ns (61.6% faster)

def test_manual_and_ask_message_are_deterministic():
    # Ensure repeated calls return the same message for each mode
    codeflash_output = _get_mode_intro_message("manual"); manual_msg_1 = codeflash_output # 496ns -> 313ns (58.5% faster)
    codeflash_output = _get_mode_intro_message("manual"); manual_msg_2 = codeflash_output # 255ns -> 146ns (74.7% faster)
    codeflash_output = _get_mode_intro_message("ask"); ask_msg_1 = codeflash_output # 324ns -> 181ns (79.0% faster)
    codeflash_output = _get_mode_intro_message("ask"); ask_msg_2 = codeflash_output # 169ns -> 126ns (34.1% faster)
# 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-_get_mode_intro_message-mh5k75a1 and push.