⚡️ Speed up function is_mcp_config_empty by 16%

[codeflash-ai]

📄 16% (0.16x) speedup for is_mcp_config_empty in marimo/_server/ai/mcp/config.py

⏱️ Runtime : 44.7 microseconds → 38.5 microseconds (best of 216 runs)

📝 Explanation and details

The optimized code achieves a 16% speedup by implementing short-circuit evaluation to avoid unnecessary dictionary lookups and boolean operations.

Key optimization:

• Early return pattern: Instead of evaluating both config.get("mcpServers") and config.get("presets") in a single boolean expression, the optimized version checks mcpServers first and returns False immediately if it's truthy
• Reduced dictionary lookups: When mcpServers is non-empty (which happens in many test cases), the code avoids the second config.get("presets") call entirely

Performance impact by test case type:

• Best gains (17-55% faster): Cases where mcpServers is non-empty, because the optimization completely skips the presets lookup
• Modest gains (4-23% faster): Cases where both keys are empty/falsy, benefiting from cleaner control flow
• Slight regressions (1-9% slower): A few edge cases where presets is non-empty but mcpServers is empty, due to the extra variable assignment and conditional check overhead

The optimization is particularly effective for the common scenario where configurations have non-empty mcpServers, allowing the function to return early without evaluating the second condition.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 76 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.mcp.config import is_mcp_config_empty

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


# Minimal MCPConfig stub for testing (since real import is unavailable)
class MCPConfig(dict):
    pass
from marimo._server.ai.mcp.config import is_mcp_config_empty

# unit tests

# -------------------------
# 1. Basic Test Cases
# -------------------------

def test_none_config_is_empty():
    # Test when config is None
    codeflash_output = is_mcp_config_empty(None) # 383ns -> 352ns (8.81% faster)

def test_empty_config_dict_is_empty():
    # Test when config is an empty dict
    config = MCPConfig()
    codeflash_output = is_mcp_config_empty(config) # 583ns -> 560ns (4.11% faster)

def test_config_with_empty_lists_is_empty():
    # Test when 'mcpServers' and 'presets' are present but empty
    config = MCPConfig({"mcpServers": [], "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 589ns -> 569ns (3.51% faster)

def test_config_with_one_nonempty_mcpServers_is_not_empty():
    # Test when 'mcpServers' is non-empty, 'presets' is empty
    config = MCPConfig({"mcpServers": ["server1"], "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 539ns -> 460ns (17.2% faster)

def test_config_with_one_nonempty_presets_is_not_empty():
    # Test when 'presets' is non-empty, 'mcpServers' is empty
    config = MCPConfig({"mcpServers": [], "presets": ["preset1"]})
    codeflash_output = is_mcp_config_empty(config) # 541ns -> 594ns (8.92% slower)

def test_config_with_both_nonempty_is_not_empty():
    # Test when both 'mcpServers' and 'presets' are non-empty
    config = MCPConfig({"mcpServers": ["server1"], "presets": ["preset1"]})
    codeflash_output = is_mcp_config_empty(config) # 496ns -> 439ns (13.0% faster)

def test_config_with_extra_keys_and_empty_lists_is_empty():
    # Test config with extra unrelated keys, but 'mcpServers' and 'presets' are empty
    config = MCPConfig({"foo": 123, "mcpServers": [], "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 534ns -> 550ns (2.91% slower)

def test_config_with_extra_keys_and_nonempty_mcpServers_is_not_empty():
    # Test config with extra unrelated keys, 'mcpServers' is non-empty
    config = MCPConfig({"foo": 123, "mcpServers": ["server1"], "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 521ns -> 432ns (20.6% faster)

# -------------------------
# 2. Edge Test Cases
# -------------------------

def test_config_missing_mcpServers_key_is_empty_if_presets_empty():
    # Test config missing 'mcpServers' key, 'presets' is empty
    config = MCPConfig({"presets": []})
    codeflash_output = is_mcp_config_empty(config) # 599ns -> 556ns (7.73% faster)

def test_config_missing_presets_key_is_empty_if_mcpServers_empty():
    # Test config missing 'presets' key, 'mcpServers' is empty
    config = MCPConfig({"mcpServers": []})
    codeflash_output = is_mcp_config_empty(config) # 587ns -> 538ns (9.11% faster)

def test_config_missing_both_keys_is_empty():
    # Test config missing both 'mcpServers' and 'presets'
    config = MCPConfig({"foo": "bar"})
    codeflash_output = is_mcp_config_empty(config) # 546ns -> 507ns (7.69% faster)

def test_config_with_mcpServers_none_is_empty_if_presets_empty():
    # Test 'mcpServers' is None, 'presets' is empty
    config = MCPConfig({"mcpServers": None, "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 585ns -> 501ns (16.8% faster)

def test_config_with_presets_none_is_empty_if_mcpServers_empty():
    # Test 'presets' is None, 'mcpServers' is empty
    config = MCPConfig({"mcpServers": [], "presets": None})
    codeflash_output = is_mcp_config_empty(config) # 549ns -> 525ns (4.57% faster)

def test_config_with_mcpServers_none_and_presets_none_is_empty():
    # Test both 'mcpServers' and 'presets' are None
    config = MCPConfig({"mcpServers": None, "presets": None})
    codeflash_output = is_mcp_config_empty(config) # 528ns -> 498ns (6.02% faster)

def test_config_with_mcpServers_nonempty_and_presets_none_is_not_empty():
    # Test 'mcpServers' is non-empty, 'presets' is None
    config = MCPConfig({"mcpServers": ["server1"], "presets": None})
    codeflash_output = is_mcp_config_empty(config) # 546ns -> 414ns (31.9% faster)

def test_config_with_presets_nonempty_and_mcpServers_none_is_not_empty():
    # Test 'presets' is non-empty, 'mcpServers' is None
    config = MCPConfig({"mcpServers": None, "presets": ["preset1"]})
    codeflash_output = is_mcp_config_empty(config) # 553ns -> 555ns (0.360% slower)

def test_config_with_mcpServers_empty_string_and_presets_empty():
    # Test 'mcpServers' is empty string, which is falsy
    config = MCPConfig({"mcpServers": "", "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 555ns -> 517ns (7.35% faster)

def test_config_with_presets_empty_string_and_mcpServers_empty():
    # Test 'presets' is empty string, which is falsy
    config = MCPConfig({"mcpServers": [], "presets": ""})
    codeflash_output = is_mcp_config_empty(config) # 543ns -> 523ns (3.82% faster)

def test_config_with_mcpServers_empty_dict_and_presets_empty():
    # Test 'mcpServers' is empty dict, which is falsy
    config = MCPConfig({"mcpServers": {}, "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 524ns -> 541ns (3.14% slower)

def test_config_with_presets_empty_dict_and_mcpServers_empty():
    # Test 'presets' is empty dict, which is falsy
    config = MCPConfig({"mcpServers": [], "presets": {}})
    codeflash_output = is_mcp_config_empty(config) # 579ns -> 531ns (9.04% faster)

def test_config_with_mcpServers_nonempty_dict_and_presets_empty():
    # Test 'mcpServers' is non-empty dict, which is truthy
    config = MCPConfig({"mcpServers": {"a": 1}, "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 531ns -> 451ns (17.7% faster)

def test_config_with_presets_nonempty_dict_and_mcpServers_empty():
    # Test 'presets' is non-empty dict, which is truthy
    config = MCPConfig({"mcpServers": [], "presets": {"b": 2}})
    codeflash_output = is_mcp_config_empty(config) # 607ns -> 569ns (6.68% faster)

def test_config_with_mcpServers_zero_and_presets_empty():
    # Test 'mcpServers' is 0, which is falsy
    config = MCPConfig({"mcpServers": 0, "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 536ns -> 551ns (2.72% slower)

def test_config_with_presets_zero_and_mcpServers_empty():
    # Test 'presets' is 0, which is falsy
    config = MCPConfig({"mcpServers": [], "presets": 0})
    codeflash_output = is_mcp_config_empty(config) # 549ns -> 536ns (2.43% faster)

def test_config_with_mcpServers_false_and_presets_empty():
    # Test 'mcpServers' is False, which is falsy
    config = MCPConfig({"mcpServers": False, "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 571ns -> 513ns (11.3% faster)

def test_config_with_presets_false_and_mcpServers_empty():
    # Test 'presets' is False, which is falsy
    config = MCPConfig({"mcpServers": [], "presets": False})
    codeflash_output = is_mcp_config_empty(config) # 561ns -> 514ns (9.14% faster)

def test_config_with_mcpServers_true_and_presets_empty():
    # Test 'mcpServers' is True, which is truthy
    config = MCPConfig({"mcpServers": True, "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 535ns -> 432ns (23.8% faster)

def test_config_with_presets_true_and_mcpServers_empty():
    # Test 'presets' is True, which is truthy
    config = MCPConfig({"mcpServers": [], "presets": True})
    codeflash_output = is_mcp_config_empty(config) # 558ns -> 548ns (1.82% faster)

def test_config_with_mcpServers_empty_tuple_and_presets_empty():
    # Test 'mcpServers' is empty tuple, which is falsy
    config = MCPConfig({"mcpServers": (), "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 521ns -> 550ns (5.27% slower)

def test_config_with_presets_empty_tuple_and_mcpServers_empty():
    # Test 'presets' is empty tuple, which is falsy
    config = MCPConfig({"mcpServers": [], "presets": ()})
    codeflash_output = is_mcp_config_empty(config) # 554ns -> 531ns (4.33% faster)

def test_config_with_mcpServers_nonempty_tuple_and_presets_empty():
    # Test 'mcpServers' is non-empty tuple, which is truthy
    config = MCPConfig({"mcpServers": ("server1",), "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 534ns -> 445ns (20.0% faster)

def test_config_with_presets_nonempty_tuple_and_mcpServers_empty():
    # Test 'presets' is non-empty tuple, which is truthy
    config = MCPConfig({"mcpServers": [], "presets": ("preset1",)})
    codeflash_output = is_mcp_config_empty(config) # 595ns -> 547ns (8.78% faster)

# -------------------------
# 3. Large Scale Test Cases
# -------------------------

def test_config_with_large_empty_lists_is_empty():
    # Test with large empty lists
    config = MCPConfig({"mcpServers": [], "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 551ns -> 526ns (4.75% faster)

def test_config_with_large_nonempty_mcpServers_is_not_empty():
    # Test with large non-empty mcpServers
    config = MCPConfig({"mcpServers": ["server{}".format(i) for i in range(1000)], "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 517ns -> 436ns (18.6% faster)

def test_config_with_large_nonempty_presets_is_not_empty():
    # Test with large non-empty presets
    config = MCPConfig({"mcpServers": [], "presets": ["preset{}".format(i) for i in range(1000)]})
    codeflash_output = is_mcp_config_empty(config) # 561ns -> 595ns (5.71% slower)

def test_config_with_large_nonempty_both_is_not_empty():
    # Test with both mcpServers and presets non-empty and large
    config = MCPConfig({
        "mcpServers": ["server{}".format(i) for i in range(500)],
        "presets": ["preset{}".format(i) for i in range(500)]
    })
    codeflash_output = is_mcp_config_empty(config) # 493ns -> 432ns (14.1% faster)

def test_config_with_large_dicts_is_not_empty():
    # Test with large dicts as values
    config = MCPConfig({
        "mcpServers": {str(i): i for i in range(1000)},
        "presets": {}
    })
    codeflash_output = is_mcp_config_empty(config) # 518ns -> 481ns (7.69% faster)

def test_config_with_large_dicts_empty_is_empty():
    # Test with large empty dicts as values
    config = MCPConfig({
        "mcpServers": {},
        "presets": {}
    })
    codeflash_output = is_mcp_config_empty(config) # 543ns -> 584ns (7.02% slower)

def test_config_with_large_tuple_is_not_empty():
    # Test with large non-empty tuple as value
    config = MCPConfig({
        "mcpServers": tuple("server{}".format(i) for i in range(1000)),
        "presets": []
    })
    codeflash_output = is_mcp_config_empty(config) # 514ns -> 430ns (19.5% faster)

def test_config_with_large_tuple_empty_is_empty():
    # Test with large empty tuple as value
    config = MCPConfig({
        "mcpServers": (),
        "presets": []
    })
    codeflash_output = is_mcp_config_empty(config) # 582ns -> 554ns (5.05% faster)

def test_config_with_large_lists_and_extra_keys_is_not_empty():
    # Test with large lists and extra unrelated keys
    config = MCPConfig({
        "mcpServers": ["server{}".format(i) for i in range(999)],
        "presets": [],
        "extra": "value"
    })
    codeflash_output = is_mcp_config_empty(config) # 490ns -> 437ns (12.1% faster)

def test_config_with_large_lists_and_extra_keys_is_empty():
    # Test with large empty lists and extra unrelated keys
    config = MCPConfig({
        "mcpServers": [],
        "presets": [],
        "extra": "value"
    })
    codeflash_output = is_mcp_config_empty(config) # 514ns -> 526ns (2.28% slower)
# 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.mcp.config import is_mcp_config_empty

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


# Minimal stub for MCPConfig to allow testing.
class MCPConfig(dict):
    pass
from marimo._server.ai.mcp.config import is_mcp_config_empty

# unit tests

# --------------- BASIC TEST CASES ------------------

def test_none_config_returns_true():
    # None should be considered empty
    codeflash_output = is_mcp_config_empty(None) # 367ns -> 324ns (13.3% faster)

def test_empty_dict_returns_true():
    # Empty MCPConfig should be considered empty
    config = MCPConfig()
    codeflash_output = is_mcp_config_empty(config) # 748ns -> 536ns (39.6% faster)

def test_empty_mcpServers_and_presets_returns_true():
    # Both keys present but empty
    config = MCPConfig({"mcpServers": [], "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 678ns -> 574ns (18.1% faster)

def test_non_empty_mcpServers_returns_false():
    # Non-empty mcpServers, empty presets
    config = MCPConfig({"mcpServers": ["server1"], "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 641ns -> 418ns (53.3% faster)

def test_non_empty_presets_returns_false():
    # Empty mcpServers, non-empty presets
    config = MCPConfig({"mcpServers": [], "presets": ["preset1"]})
    codeflash_output = is_mcp_config_empty(config) # 668ns -> 595ns (12.3% faster)

def test_both_non_empty_returns_false():
    # Both mcpServers and presets are non-empty
    config = MCPConfig({"mcpServers": ["server1"], "presets": ["preset1"]})
    codeflash_output = is_mcp_config_empty(config) # 628ns -> 443ns (41.8% faster)

# --------------- EDGE TEST CASES ------------------

def test_missing_mcpServers_key():
    # 'mcpServers' key missing, 'presets' empty
    config = MCPConfig({"presets": []})
    codeflash_output = is_mcp_config_empty(config) # 708ns -> 574ns (23.3% faster)

def test_missing_presets_key():
    # 'presets' key missing, 'mcpServers' empty
    config = MCPConfig({"mcpServers": []})
    codeflash_output = is_mcp_config_empty(config) # 704ns -> 546ns (28.9% faster)

def test_missing_both_keys():
    # Both keys missing
    config = MCPConfig({"otherKey": "value"})
    codeflash_output = is_mcp_config_empty(config) # 602ns -> 526ns (14.4% faster)

def test_mcpServers_none_presets_none():
    # Both keys present but set to None
    config = MCPConfig({"mcpServers": None, "presets": None})
    codeflash_output = is_mcp_config_empty(config) # 654ns -> 496ns (31.9% faster)

def test_mcpServers_none_presets_non_empty():
    # mcpServers is None, presets is non-empty
    config = MCPConfig({"mcpServers": None, "presets": ["preset1"]})
    codeflash_output = is_mcp_config_empty(config) # 675ns -> 571ns (18.2% faster)

def test_mcpServers_non_empty_presets_none():
    # mcpServers is non-empty, presets is None
    config = MCPConfig({"mcpServers": ["server1"], "presets": None})
    codeflash_output = is_mcp_config_empty(config) # 622ns -> 413ns (50.6% faster)

def test_mcpServers_wrong_type():
    # mcpServers is not a list (e.g., string), presets empty
    config = MCPConfig({"mcpServers": "notalist", "presets": []})
    # Non-empty string should be considered non-empty
    codeflash_output = is_mcp_config_empty(config) # 605ns -> 437ns (38.4% faster)

def test_presets_wrong_type():
    # presets is not a list (e.g., integer), mcpServers empty
    config = MCPConfig({"mcpServers": [], "presets": 123})
    # Non-zero int should be considered non-empty
    codeflash_output = is_mcp_config_empty(config) # 661ns -> 538ns (22.9% faster)

def test_mcpServers_empty_string_presets_empty():
    # mcpServers is empty string, presets is empty
    config = MCPConfig({"mcpServers": "", "presets": []})
    # Empty string should be considered empty
    codeflash_output = is_mcp_config_empty(config) # 649ns -> 518ns (25.3% faster)

def test_presets_empty_string_mcpServers_empty():
    # presets is empty string, mcpServers is empty
    config = MCPConfig({"mcpServers": [], "presets": ""})
    codeflash_output = is_mcp_config_empty(config) # 660ns -> 557ns (18.5% faster)

def test_mcpServers_false_presets_false():
    # Both keys present and set to False
    config = MCPConfig({"mcpServers": False, "presets": False})
    codeflash_output = is_mcp_config_empty(config) # 588ns -> 495ns (18.8% faster)

def test_mcpServers_zero_presets_zero():
    # Both keys present and set to 0
    config = MCPConfig({"mcpServers": 0, "presets": 0})
    codeflash_output = is_mcp_config_empty(config) # 593ns -> 486ns (22.0% faster)

def test_mcpServers_dict_presets_dict():
    # Both keys present and set to non-empty dicts
    config = MCPConfig({"mcpServers": {"a": 1}, "presets": {"b": 2}})
    codeflash_output = is_mcp_config_empty(config) # 654ns -> 435ns (50.3% faster)

def test_mcpServers_empty_dict_presets_empty_dict():
    # Both keys present and set to empty dicts
    config = MCPConfig({"mcpServers": {}, "presets": {}})
    codeflash_output = is_mcp_config_empty(config) # 666ns -> 503ns (32.4% faster)

def test_mcpServers_set_presets_set():
    # Both keys present and set to non-empty sets
    config = MCPConfig({"mcpServers": {1}, "presets": {2}})
    codeflash_output = is_mcp_config_empty(config) # 613ns -> 426ns (43.9% faster)

def test_mcpServers_empty_set_presets_empty_set():
    # Both keys present and set to empty sets
    config = MCPConfig({"mcpServers": set(), "presets": set()})
    codeflash_output = is_mcp_config_empty(config) # 657ns -> 572ns (14.9% faster)

def test_mcpServers_tuple_presets_tuple():
    # Both keys present and set to non-empty tuples
    config = MCPConfig({"mcpServers": (1,), "presets": (2,)})
    codeflash_output = is_mcp_config_empty(config) # 622ns -> 457ns (36.1% faster)

def test_mcpServers_empty_tuple_presets_empty_tuple():
    # Both keys present and set to empty tuples
    config = MCPConfig({"mcpServers": (), "presets": ()})
    codeflash_output = is_mcp_config_empty(config) # 664ns -> 556ns (19.4% faster)

# --------------- LARGE SCALE TEST CASES ------------------

def test_large_empty_lists():
    # Large empty lists for both keys
    config = MCPConfig({"mcpServers": [], "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 640ns -> 546ns (17.2% faster)

def test_large_non_empty_mcpServers():
    # Large non-empty mcpServers, empty presets
    config = MCPConfig({"mcpServers": [f"server{i}" for i in range(1000)], "presets": []})
    codeflash_output = is_mcp_config_empty(config) # 634ns -> 408ns (55.4% faster)

def test_large_non_empty_presets():
    # Empty mcpServers, large non-empty presets
    config = MCPConfig({"mcpServers": [], "presets": [f"preset{i}" for i in range(1000)]})
    codeflash_output = is_mcp_config_empty(config) # 652ns -> 588ns (10.9% faster)

def test_large_both_non_empty():
    # Both keys have large non-empty lists
    config = MCPConfig({
        "mcpServers": [f"server{i}" for i in range(1000)],
        "presets": [f"preset{i}" for i in range(1000)]
    })
    codeflash_output = is_mcp_config_empty(config) # 597ns -> 430ns (38.8% faster)

def test_large_both_empty_dicts():
    # Both keys have large empty dicts
    config = MCPConfig({"mcpServers": {}, "presets": {}})
    codeflash_output = is_mcp_config_empty(config) # 656ns -> 565ns (16.1% faster)

def test_large_both_non_empty_dicts():
    # Both keys have large non-empty dicts
    config = MCPConfig({
        "mcpServers": {i: f"server{i}" for i in range(1000)},
        "presets": {i: f"preset{i}" for i in range(1000)}
    })
    codeflash_output = is_mcp_config_empty(config) # 643ns -> 472ns (36.2% faster)

def test_large_both_non_empty_sets():
    # Both keys have large non-empty sets
    config = MCPConfig({
        "mcpServers": set(range(1000)),
        "presets": set(range(1000))
    })
    codeflash_output = is_mcp_config_empty(config) # 696ns -> 479ns (45.3% faster)

def test_large_both_empty_sets():
    # Both keys have large empty sets
    config = MCPConfig({
        "mcpServers": set(),
        "presets": set()
    })
    codeflash_output = is_mcp_config_empty(config) # 686ns -> 606ns (13.2% faster)

def test_large_mixed_types():
    # Large list for mcpServers, large dict for presets
    config = MCPConfig({
        "mcpServers": [f"server{i}" for i in range(1000)],
        "presets": {i: f"preset{i}" for i in range(1000)}
    })
    codeflash_output = is_mcp_config_empty(config) # 659ns -> 481ns (37.0% faster)

def test_large_missing_keys():
    # Large config with many keys, but missing mcpServers and presets
    config = MCPConfig({f"key{i}": i for i in range(1000)})
    codeflash_output = is_mcp_config_empty(config) # 711ns -> 578ns (23.0% 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-is_mcp_config_empty-mgiig95t and push.