⚡️ Speed up function any_lsp_server_running by 283%

[codeflash-ai]

📄 283% (2.83x) speedup for any_lsp_server_running in marimo/_server/lsp.py

⏱️ Runtime : 891 microseconds → 233 microseconds (best of 156 runs)

📝 Explanation and details

The optimized code achieves a 282% speedup by replacing the expensive any() function with manual iteration that includes early exit logic and removing unnecessary type casting.

Key optimizations:

1. Early exit on first enabled server: Instead of using any() which must create a generator and evaluate all language servers, the optimized version uses a manual for loop that returns immediately when it finds the first enabled server. This is particularly effective when an enabled server appears early in the iteration.

2. Eliminated cast() operation: Removed the cast(dict[str, Any], server) call inside the loop, which was being executed for every language server. The line profiler shows this was consuming significant time (98% of total time in the original).

3. Short-circuit evaluation: When an enabled server is found, the function returns (copilot_enabled is not False) or True, which always evaluates to True, avoiding any additional computation.

Performance impact by test case:

• Massive gains on large datasets: Tests with 1000 language servers show 320-343% speedups, demonstrating the early exit benefit
• Consistent improvements on small datasets: Even simple cases with 1-3 language servers show 50-155% improvements due to eliminated overhead
• Best performance when enabled servers appear early: The "first enabled" test case shows similar performance to "all enabled", confirming early exit effectiveness

The optimization is particularly valuable since language server configuration checking likely occurs frequently during development workflows, and the early exit pattern handles the common case where only a few servers are enabled among many configured options.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 48 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.lsp import any_lsp_server_running

unit tests

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

def test_copilot_enabled_true():
# Copilot enabled, no language servers
config = {
"completion": {"copilot": True},
"language_servers": {}
}
codeflash_output = any_lsp_server_running(config) # 1.57μs -> 935ns (67.5% faster)

def test_copilot_enabled_false():
# Copilot disabled, no language servers
config = {
"completion": {"copilot": False},
"language_servers": {}
}
codeflash_output = any_lsp_server_running(config) # 1.37μs -> 754ns (81.6% faster)

def test_copilot_enabled_none():
# Copilot set to None, should be treated as enabled
config = {
"completion": {"copilot": None},
"language_servers": {}
}
codeflash_output = any_lsp_server_running(config) # 1.31μs -> 777ns (69.1% faster)

def test_one_language_server_enabled():
# Copilot disabled, one language server enabled
config = {
"completion": {"copilot": False},
"language_servers": {
"python": {"enabled": True}
}
}
codeflash_output = any_lsp_server_running(config) # 2.48μs -> 959ns (158% faster)

def test_multiple_language_servers_some_enabled():
# Copilot disabled, multiple language servers, one enabled
config = {
"completion": {"copilot": False},
"language_servers": {
"python": {"enabled": False},
"typescript": {"enabled": True},
"go": {"enabled": False}
}
}
codeflash_output = any_lsp_server_running(config) # 2.59μs -> 1.02μs (155% faster)

def test_multiple_language_servers_none_enabled():
# Copilot disabled, multiple language servers, none enabled
config = {
"completion": {"copilot": False},
"language_servers": {
"python": {"enabled": False},
"typescript": {"enabled": False}
}
}
codeflash_output = any_lsp_server_running(config) # 2.36μs -> 995ns (138% faster)

def test_language_servers_empty_dict():
# Copilot disabled, language_servers is empty dict
config = {
"completion": {"copilot": False},
"language_servers": {}
}
codeflash_output = any_lsp_server_running(config) # 1.33μs -> 835ns (59.5% faster)

def test_language_servers_missing():
# Copilot disabled, language_servers key missing
config = {
"completion": {"copilot": False}
}
codeflash_output = any_lsp_server_running(config) # 1.39μs -> 804ns (72.4% faster)

def test_copilot_missing():
# Copilot key missing, should raise KeyError
config = {
"completion": {},
"language_servers": {}
}
with pytest.raises(KeyError):
any_lsp_server_running(config) # 805ns -> 749ns (7.48% faster)

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

def test_language_server_enabled_missing_key():
# Copilot disabled, language server missing 'enabled' key (should default to False)
config = {
"completion": {"copilot": False},
"language_servers": {
"python": {},
"typescript": {"enabled": False}
}
}
codeflash_output = any_lsp_server_running(config) # 2.55μs -> 1.06μs (139% faster)

def test_language_server_enabled_non_bool():
# Copilot disabled, language server enabled is non-bool but truthy
config = {
"completion": {"copilot": False},
"language_servers": {
"python": {"enabled": 1}, # 1 is truthy
"typescript": {"enabled": 0} # 0 is falsy
}
}
codeflash_output = any_lsp_server_running(config) # 2.32μs -> 973ns (139% faster)

def test_language_server_enabled_string_true():
# Copilot disabled, language server enabled is string "True" (truthy)
config = {
"completion": {"copilot": False},
"language_servers": {
"python": {"enabled": "True"}
}
}
codeflash_output = any_lsp_server_running(config) # 2.29μs -> 990ns (131% faster)

def test_language_server_enabled_string_false():
# Copilot disabled, language server enabled is string "False" (truthy, non-empty string)
config = {
"completion": {"copilot": False},
"language_servers": {
"python": {"enabled": "False"}
}
}
codeflash_output = any_lsp_server_running(config) # 2.19μs -> 955ns (130% faster)

def test_copilot_enabled_empty_string():
# Copilot enabled with empty string (falsy)
config = {
"completion": {"copilot": ""},
"language_servers": {}
}
codeflash_output = any_lsp_server_running(config) # 1.35μs -> 798ns (68.9% faster)

def test_copilot_enabled_zero():
# Copilot enabled with zero (falsy)
config = {
"completion": {"copilot": 0},
"language_servers": {}
}
codeflash_output = any_lsp_server_running(config) # 1.31μs -> 802ns (63.2% faster)

def test_language_servers_is_list():
# language_servers is a list, not a dict, should raise AttributeError
config = {
"completion": {"copilot": False},
"language_servers": [{"enabled": True}]
}
with pytest.raises(AttributeError):
any_lsp_server_running(config) # 1.82μs -> 1.50μs (21.2% faster)

def test_language_servers_is_string():
# language_servers is a string, not a dict, should raise AttributeError
config = {
"completion": {"copilot": False},
"language_servers": "not a dict"
}
with pytest.raises(AttributeError):
any_lsp_server_running(config) # 1.73μs -> 1.39μs (24.0% faster)

def test_language_servers_values_are_non_dict():
# language_servers values are not dicts, should raise AttributeError
config = {
"completion": {"copilot": False},
"language_servers": {
"python": "not a dict"
}
}
with pytest.raises(AttributeError):
any_lsp_server_running(config) # 3.19μs -> 1.89μs (69.1% faster)

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

def test_large_number_language_servers_all_disabled():
# Large number of language servers, all disabled
config = {
"completion": {"copilot": False},
"language_servers": {
f"lang_{i}": {"enabled": False} for i in range(1000)
}
}
codeflash_output = any_lsp_server_running(config) # 117μs -> 27.8μs (322% faster)

def test_large_number_language_servers_one_enabled_first():
# Large number, first enabled
config = {
"completion": {"copilot": False},
"language_servers": {
"lang_0": {"enabled": True},
**{f"lang_{i}": {"enabled": False} for i in range(1, 1000)}
}
}
codeflash_output = any_lsp_server_running(config) # 2.57μs -> 1.02μs (152% faster)

def test_large_number_language_servers_one_enabled_last():
# Large number, last enabled
config = {
"completion": {"copilot": False},
"language_servers": {
**{f"lang_{i}": {"enabled": False} for i in range(999)},
"lang_999": {"enabled": True}
}
}
codeflash_output = any_lsp_server_running(config) # 116μs -> 27.3μs (326% faster)

def test_large_number_language_servers_all_enabled():
# Large number, all enabled
config = {
"completion": {"copilot": False},
"language_servers": {
f"lang_{i}": {"enabled": True} for i in range(1000)
}
}
codeflash_output = any_lsp_server_running(config) # 2.54μs -> 1.01μs (152% faster)

def test_large_number_language_servers_varied_enabled():
# Large number, every 10th enabled
config = {
"completion": {"copilot": False},
"language_servers": {
f"lang_{i}": {"enabled": (i % 10 == 0)} for i in range(1000)
}
}
codeflash_output = any_lsp_server_running(config) # 2.45μs -> 1.01μs (144% faster)

def test_large_number_language_servers_all_missing_enabled():
# Large number, all missing 'enabled' key
config = {
"completion": {"copilot": False},
"language_servers": {
f"lang_{i}": {} for i in range(1000)
}
}
codeflash_output = any_lsp_server_running(config) # 114μs -> 25.8μs (343% faster)

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

#------------------------------------------------
from typing import Any, cast

imports

import pytest # used for our unit tests
from marimo._server.lsp import any_lsp_server_running

function to test

Copyright 2025 Marimo. All rights reserved.

class MarimoConfig(dict):
"""A simple dict subclass to mimic MarimoConfig for testing."""
pass
from marimo._server.lsp import any_lsp_server_running

unit tests

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

def test_copilot_enabled_true():
"""Copilot explicitly enabled, no language servers."""
config = MarimoConfig({
"completion": {"copilot": True},
"language_servers": {}
})
codeflash_output = any_lsp_server_running(config) # 1.78μs -> 1.16μs (53.4% faster)

def test_copilot_enabled_false_no_servers():
"""Copilot disabled, no language servers."""
config = MarimoConfig({
"completion": {"copilot": False},
"language_servers": {}
})
codeflash_output = any_lsp_server_running(config) # 1.48μs -> 971ns (52.6% faster)

def test_language_server_enabled():
"""Copilot disabled, one language server enabled."""
config = MarimoConfig({
"completion": {"copilot": False},
"language_servers": {
"python": {"enabled": True}
}
})
codeflash_output = any_lsp_server_running(config) # 2.40μs -> 1.15μs (108% faster)

def test_language_server_disabled():
"""Copilot disabled, one language server disabled."""
config = MarimoConfig({
"completion": {"copilot": False},
"language_servers": {
"python": {"enabled": False}
}
})
codeflash_output = any_lsp_server_running(config) # 2.18μs -> 1.14μs (90.7% faster)

def test_multiple_language_servers_one_enabled():
"""Copilot disabled, multiple language servers, one enabled."""
config = MarimoConfig({
"completion": {"copilot": False},
"language_servers": {
"python": {"enabled": False},
"javascript": {"enabled": True},
"go": {"enabled": False}
}
})
codeflash_output = any_lsp_server_running(config) # 2.57μs -> 1.21μs (113% faster)

def test_multiple_language_servers_none_enabled():
"""Copilot disabled, multiple language servers, none enabled."""
config = MarimoConfig({
"completion": {"copilot": False},
"language_servers": {
"python": {"enabled": False},
"javascript": {"enabled": False},
"go": {"enabled": False}
}
})
codeflash_output = any_lsp_server_running(config) # 2.44μs -> 1.20μs (104% faster)

def test_copilot_enabled_and_language_server_enabled():
"""Copilot enabled, language server enabled."""
config = MarimoConfig({
"completion": {"copilot": True},
"language_servers": {
"python": {"enabled": True}
}
})
codeflash_output = any_lsp_server_running(config) # 2.31μs -> 1.08μs (114% faster)

def test_copilot_enabled_and_language_server_disabled():
"""Copilot enabled, language server disabled."""
config = MarimoConfig({
"completion": {"copilot": True},
"language_servers": {
"python": {"enabled": False}
}
})
codeflash_output = any_lsp_server_running(config) # 1.98μs -> 1.10μs (80.7% faster)

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

def test_missing_language_servers_key():
"""Config missing 'language_servers' key."""
config = MarimoConfig({
"completion": {"copilot": False}
# No 'language_servers'
})
codeflash_output = any_lsp_server_running(config) # 1.50μs -> 966ns (55.1% faster)

def test_missing_enabled_key_in_server():
"""Language server config missing 'enabled' key (should default to False)."""
config = MarimoConfig({
"completion": {"copilot": False},
"language_servers": {
"python": {} # 'enabled' key missing
}
})
codeflash_output = any_lsp_server_running(config) # 2.19μs -> 1.10μs (99.4% faster)

def test_enabled_key_none():
"""Language server 'enabled' key is None (should treat as False)."""
config = MarimoConfig({
"completion": {"copilot": False},
"language_servers": {
"python": {"enabled": None}
}
})
codeflash_output = any_lsp_server_running(config) # 2.11μs -> 1.09μs (94.3% faster)

def test_enabled_key_non_boolean_truthy():
"""Language server 'enabled' key is a non-boolean truthy value."""
config = MarimoConfig({
"completion": {"copilot": False},
"language_servers": {
"python": {"enabled": 1}
}
})
codeflash_output = any_lsp_server_running(config) # 2.27μs -> 1.09μs (108% faster)

def test_enabled_key_non_boolean_falsy():
"""Language server 'enabled' key is a non-boolean falsy value."""
config = MarimoConfig({
"completion": {"copilot": False},
"language_servers": {
"python": {"enabled": 0}
}
})
codeflash_output = any_lsp_server_running(config) # 2.07μs -> 1.07μs (93.0% faster)

def test_copilot_enabled_none():
"""Copilot 'enabled' is None (should treat as enabled)."""
config = MarimoConfig({
"completion": {"copilot": None},
"language_servers": {}
})
codeflash_output = any_lsp_server_running(config) # 1.47μs -> 993ns (48.1% faster)

def test_copilot_enabled_string():
"""Copilot 'enabled' is a non-False string (should treat as enabled)."""
config = MarimoConfig({
"completion": {"copilot": "yes"},
"language_servers": {}
})
codeflash_output = any_lsp_server_running(config) # 1.46μs -> 944ns (55.0% faster)

def test_language_servers_empty_dict():
"""Language servers dict is empty."""
config = MarimoConfig({
"completion": {"copilot": False},
"language_servers": {}
})
codeflash_output = any_lsp_server_running(config) # 1.47μs -> 952ns (53.9% faster)

def test_language_servers_multiple_types():
"""Language servers dict contains mixed types."""
config = MarimoConfig({
"completion": {"copilot": False},
"language_servers": {
"python": {"enabled": True},
"javascript": [],
"go": None,
"ruby": {"enabled": False}
}
})
codeflash_output = any_lsp_server_running(config) # 3.06μs -> 1.47μs (108% faster)

def test_completion_key_missing():
"""Config missing 'completion' key should raise KeyError."""
config = MarimoConfig({
"language_servers": {}
})
with pytest.raises(KeyError):
any_lsp_server_running(config) # 990ns -> 904ns (9.51% faster)

def test_copilot_key_missing():
"""Config missing 'copilot' key in 'completion' should raise KeyError."""
config = MarimoConfig({
"completion": {},
"language_servers": {}
})
with pytest.raises(KeyError):
any_lsp_server_running(config) # 955ns -> 910ns (4.95% faster)

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

def test_large_number_of_language_servers_all_disabled():
"""1000 language servers, all disabled."""
config = MarimoConfig({
"completion": {"copilot": False},
"language_servers": {
f"server{i}": {"enabled": False} for i in range(1000)
}
})
codeflash_output = any_lsp_server_running(config) # 116μs -> 27.8μs (320% faster)

def test_large_number_of_language_servers_one_enabled():
"""999 language servers disabled, one enabled."""
config = MarimoConfig({
"completion": {"copilot": False},
"language_servers": {
**{f"server{i}": {"enabled": False} for i in range(999)},
"server999": {"enabled": True}
}
})
codeflash_output = any_lsp_server_running(config) # 115μs -> 27.4μs (322% faster)

def test_large_number_of_language_servers_mixed_enabled():
"""500 enabled, 500 disabled language servers."""
config = MarimoConfig({
"completion": {"copilot": False},
"language_servers": {
**{f"server{i}": {"enabled": True} for i in range(500)},
**{f"server{i+500}": {"enabled": False} for i in range(500)}
}
})
codeflash_output = any_lsp_server_running(config) # 2.59μs -> 1.24μs (109% faster)

def test_large_number_of_language_servers_no_enabled_key():
"""1000 language servers, none have 'enabled' key."""
config = MarimoConfig({
"completion": {"copilot": False},
"language_servers": {
f"server{i}": {} for i in range(1000)
}
})
codeflash_output = any_lsp_server_running(config) # 113μs -> 26.1μs (335% faster)

def test_large_number_of_language_servers_copilot_enabled():
"""1000 language servers, all disabled, copilot enabled."""
config = MarimoConfig({
"completion": {"copilot": True},
"language_servers": {
f"server{i}": {"enabled": False} for i in range(1000)
}
})
codeflash_output = any_lsp_server_running(config) # 116μs -> 27.7μs (321% 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-any_lsp_server_running-mhvexuoa and push.