⚡️ Speed up function overloads_from_env by 10%

[codeflash-ai]

📄 10% (0.10x) speedup for overloads_from_env in marimo/_ast/app_config.py

⏱️ Runtime : 837 microseconds → 758 microseconds (best of 250 runs)

📝 Explanation and details

The optimized code achieves a 10% speedup through several key micro-optimizations:

1. Faster attribute checking in from_untrusted_dict:

• Replaces hasattr(config, key) with key in _AppConfig.__dataclass_fields__ - dictionary lookup is significantly faster than attribute introspection
• Uses updates.items() to avoid repeated updates[key] lookups during iteration
• Uses setattr() instead of config.__setattr__() for cleaner, marginally faster attribute setting

2. Reduced overhead in overloads_from_env:

• Pre-filters environment keys with list comprehension [key for key in os.environ if key.startswith(prefix)], avoiding repeated prefix checks
• Caches len(prefix) as lp to eliminate repeated function calls
• Caches os.environ.__getitem__ for direct dictionary access
• Computes value.lower() once as lc_value instead of calling it multiple times for boolean checks
• Eliminates redundant os.environ[key] lookups by reusing the already-fetched value

Performance characteristics from tests:

• Large-scale scenarios benefit most: 50% faster with 100 env vars, 47% faster with many environment variables
• Small workloads show mixed results: Some basic cases are 2-11% slower due to setup overhead, but complex scenarios with multiple overrides show 4-11% improvements
• The optimization shines when processing many environment variables, making it particularly valuable if this function is called frequently or in environments with many variables

The optimizations maintain identical behavior while reducing computational overhead, especially beneficial for applications that frequently process environment-based configuration.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import os
from dataclasses import dataclass, field
from typing import Any, Optional

imports

import pytest
from marimo._ast.app_config import overloads_from_env

unit tests

@pytest.mark.usefixtures("monkeypatch")
class TestOverloadsFromEnv:
# ========== BASIC TEST CASES ==========

def test_no_env_vars_returns_defaults(self, monkeypatch):
    # Remove all overload env variables
    for k in list(os.environ):
        if k.startswith("_MARIMO_APP_OVERLOAD_"):
            monkeypatch.delenv(k, raising=False)
    codeflash_output = overloads_from_env(); config = codeflash_output # 8.61μs -> 9.71μs (11.3% slower)

def test_single_string_env_var(self, monkeypatch):
    # Set a single string env var
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_APP_TITLE", "My App")
    codeflash_output = overloads_from_env(); config = codeflash_output # 11.9μs -> 11.9μs (0.076% faster)

def test_boolean_true_env_var(self, monkeypatch):
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_LAYOUT_FILE", "true")
    codeflash_output = overloads_from_env(); config = codeflash_output # 11.4μs -> 12.1μs (6.19% slower)

def test_boolean_false_env_var(self, monkeypatch):
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_CSS_FILE", "FALSE")
    codeflash_output = overloads_from_env(); config = codeflash_output # 11.3μs -> 12.1μs (6.60% slower)

def test_list_env_var(self, monkeypatch):
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", "[html,markdown]")
    codeflash_output = overloads_from_env(); config = codeflash_output # 12.7μs -> 12.7μs (0.173% slower)

def test_multiple_env_vars(self, monkeypatch):
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_APP_TITLE", "Title")
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_WIDTH", "wide")
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_SQL_OUTPUT", "table")
    codeflash_output = overloads_from_env(); config = codeflash_output # 15.0μs -> 14.8μs (1.42% faster)

# ========== EDGE TEST CASES ==========

def test_env_var_with_empty_list(self, monkeypatch):
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", "[]")
    codeflash_output = overloads_from_env(); config = codeflash_output # 12.5μs -> 12.5μs (0.376% slower)

def test_env_var_with_single_item_list(self, monkeypatch):
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", "[html]")
    codeflash_output = overloads_from_env(); config = codeflash_output # 12.4μs -> 12.5μs (1.13% slower)

def test_env_var_with_empty_string(self, monkeypatch):
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_APP_TITLE", "")
    codeflash_output = overloads_from_env(); config = codeflash_output # 11.7μs -> 12.0μs (2.47% slower)

def test_env_var_with_spaces_in_list(self, monkeypatch):
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", "[ html , markdown ]")
    codeflash_output = overloads_from_env(); config = codeflash_output # 12.5μs -> 12.6μs (0.887% slower)

def test_env_var_with_nonstandard_case(self, monkeypatch):
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_CSS_FILE", "TrUe")
    codeflash_output = overloads_from_env(); config = codeflash_output # 11.5μs -> 11.9μs (2.98% slower)

def test_env_var_with_partial_prefix(self, monkeypatch):
    # Should not be picked up
    monkeypatch.setenv("_MARIMO_APP_OVERLOADEXTRA_SQL_OUTPUT", "table")
    codeflash_output = overloads_from_env(); config = codeflash_output # 9.21μs -> 10.2μs (9.41% slower)

def test_env_var_with_unknown_key(self, monkeypatch):
    # Should be ignored
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_UNKNOWN", "foo")
    codeflash_output = overloads_from_env(); config = codeflash_output # 11.7μs -> 11.8μs (0.960% slower)

def test_env_var_with_list_with_empty_items(self, monkeypatch):
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", "[,html,]")
    codeflash_output = overloads_from_env(); config = codeflash_output # 12.7μs -> 12.9μs (1.13% slower)

def test_env_var_with_non_boolean_string(self, monkeypatch):
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_LAYOUT_FILE", "notabool")
    codeflash_output = overloads_from_env(); config = codeflash_output # 12.1μs -> 12.2μs (1.06% slower)

def test_env_var_with_nested_list_string(self, monkeypatch):
    # The parser does not handle nested lists, so this is a string
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", "[[html,markdown],pdf]")
    codeflash_output = overloads_from_env(); config = codeflash_output # 12.6μs -> 12.8μs (1.70% slower)

def test_env_var_with_trailing_and_leading_spaces(self, monkeypatch):
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_APP_TITLE", "  Hello World  ")
    codeflash_output = overloads_from_env(); config = codeflash_output # 11.9μs -> 12.0μs (0.251% slower)

# ========== LARGE SCALE TEST CASES ==========

def test_many_env_vars(self, monkeypatch):
    # Set 100 different env vars for auto_download
    for i in range(100):
        monkeypatch.setenv(f"_MARIMO_APP_OVERLOAD_APP_TITLE_{i}", f"title_{i}")
    codeflash_output = overloads_from_env(); config = codeflash_output # 123μs -> 82.4μs (50.4% faster)

def test_large_list_env_var(self, monkeypatch):
    # Test with a large list of 999 items
    items = ",".join([f"item{i}" for i in range(999)])
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", f"[{items}]")
    codeflash_output = overloads_from_env(); config = codeflash_output # 28.2μs -> 27.1μs (4.36% faster)

def test_all_fields_large_scale(self, monkeypatch):
    # Set all fields with large values
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_WIDTH", "x"*100)
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_APP_TITLE", "y"*100)
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_LAYOUT_FILE", "z"*100)
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_CSS_FILE", "a"*100)
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_HTML_HEAD_FILE", "b"*100)
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", "[" + ",".join(["html"]*999) + "]")
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_SQL_OUTPUT", "table")
    codeflash_output = overloads_from_env(); config = codeflash_output # 37.8μs -> 34.5μs (9.47% faster)

def test_env_vars_with_similar_prefixes(self, monkeypatch):
    # Should not pick up keys with similar but not exact prefixes
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD", "foo")
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_", "bar")
    monkeypatch.setenv("_MARIMO_APP_OVERLOADSQL_OUTPUT", "baz")
    codeflash_output = overloads_from_env(); config = codeflash_output # 12.3μs -> 12.6μs (2.45% slower)

def test_env_var_with_commas_in_string(self, monkeypatch):
    # Should not split unless wrapped in []
    monkeypatch.setenv("_MARIMO_APP_OVERLOAD_APP_TITLE", "hello,world")
    codeflash_output = overloads_from_env(); config = codeflash_output # 12.0μs -> 12.2μs (0.930% slower)

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

#------------------------------------------------
import os
from dataclasses import dataclass, field
from typing import Any, Optional

imports

import pytest
from marimo._ast.app_config import overloads_from_env

--- Basic Test Cases ---

def test_no_env_vars_returns_default():
"""No environment variables: should return default config."""
codeflash_output = overloads_from_env(); config = codeflash_output # 9.24μs -> 10.4μs (11.5% slower)

def test_simple_string_override(monkeypatch):
"""Set a string environment variable and check override."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_APP_TITLE", "My App")
codeflash_output = overloads_from_env(); config = codeflash_output # 12.4μs -> 12.5μs (0.858% slower)

def test_boolean_true_override(monkeypatch):
"""Set a boolean 'True' environment variable and check override."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_LAYOUT_FILE", "True")
codeflash_output = overloads_from_env(); config = codeflash_output # 11.5μs -> 12.3μs (6.69% slower)

def test_boolean_false_override(monkeypatch):
"""Set a boolean 'False' environment variable and check override."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_CSS_FILE", "false")
codeflash_output = overloads_from_env(); config = codeflash_output # 11.4μs -> 12.1μs (6.12% slower)

def test_list_override(monkeypatch):
"""Set a list environment variable and check override."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", "[html,markdown]")
codeflash_output = overloads_from_env(); config = codeflash_output # 12.6μs -> 12.8μs (1.38% slower)

def test_multiple_overrides(monkeypatch):
"""Set multiple environment variables and check all are overridden."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_APP_TITLE", "Multi")
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_WIDTH", "wide")
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_SQL_OUTPUT", "table")
codeflash_output = overloads_from_env(); config = codeflash_output # 15.4μs -> 14.8μs (4.01% faster)

--- Edge Test Cases ---

def test_empty_list(monkeypatch):
"""Set a list variable to empty list."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", "[]")
codeflash_output = overloads_from_env(); config = codeflash_output # 12.4μs -> 12.4μs (0.064% faster)

def test_list_with_spaces(monkeypatch):
"""List with spaces should not strip spaces."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", "[ html, markdown ]")
codeflash_output = overloads_from_env(); config = codeflash_output # 12.6μs -> 12.7μs (0.593% slower)

def test_list_with_one_element(monkeypatch):
"""List with one element should be parsed as list of one string."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", "[pdf]")
codeflash_output = overloads_from_env(); config = codeflash_output # 12.4μs -> 12.3μs (0.713% faster)

def test_list_with_trailing_comma(monkeypatch):
"""List with trailing comma should produce an empty string as last element."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", "[html,markdown,]")
codeflash_output = overloads_from_env(); config = codeflash_output # 12.4μs -> 12.7μs (2.32% slower)

def test_nonexistent_key(monkeypatch):
"""Set an env var that doesn't map to any config key (should be ignored)."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_NOT_A_CONFIG", "value")
codeflash_output = overloads_from_env(); config = codeflash_output # 11.6μs -> 11.6μs (0.268% faster)

def test_case_insensitivity(monkeypatch):
"""Boolean values should be case-insensitive."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_CSS_FILE", "TrUe")
codeflash_output = overloads_from_env(); config = codeflash_output # 11.3μs -> 11.9μs (4.79% slower)

def test_list_with_internal_commas(monkeypatch):
"""List with internal commas (should not split inside elements)."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", "[html,mark,down]")
codeflash_output = overloads_from_env(); config = codeflash_output # 12.6μs -> 12.4μs (1.39% faster)

def test_list_with_empty_elements(monkeypatch):
"""List with empty elements (e.g., [,,]) should produce empty strings."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", "[,,]")
codeflash_output = overloads_from_env(); config = codeflash_output # 12.6μs -> 12.4μs (1.70% faster)

def test_value_with_square_brackets_but_no_commas(monkeypatch):
"""List with brackets but no commas should produce a single-element list."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", "[single]")
codeflash_output = overloads_from_env(); config = codeflash_output # 12.3μs -> 12.5μs (1.00% slower)

def test_value_with_unmatched_brackets(monkeypatch):
"""If value starts with [ but doesn't end with ], treat as string."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_APP_TITLE", "[unmatched")
codeflash_output = overloads_from_env(); config = codeflash_output # 11.9μs -> 12.2μs (2.18% slower)

def test_value_with_extra_spaces(monkeypatch):
"""String value with leading/trailing spaces is preserved."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_APP_TITLE", " my app ")
codeflash_output = overloads_from_env(); config = codeflash_output # 11.7μs -> 12.0μs (2.33% slower)

def test_value_with_empty_string(monkeypatch):
"""Empty string value is preserved."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_APP_TITLE", "")
codeflash_output = overloads_from_env(); config = codeflash_output # 11.7μs -> 11.7μs (0.249% faster)

--- Large Scale Test Cases ---

def test_large_number_of_env_vars(monkeypatch):
"""Test function with many environment variables (up to 1000)."""
for i in range(100):
monkeypatch.setenv(f"MARIMO_APP_OVERLOAD_APP_TITLE{i}", f"title_{i}")
# Only keys matching _AppConfig fields are used, so all should be ignored
codeflash_output = overloads_from_env(); config = codeflash_output # 122μs -> 83.4μs (46.9% faster)

def test_large_list(monkeypatch):
"""Test function with a large list in the environment variable."""
large_list = ",".join(str(i) for i in range(500))
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", f"[{large_list}]")
codeflash_output = overloads_from_env(); config = codeflash_output # 20.6μs -> 19.6μs (5.09% faster)

def test_large_string_value(monkeypatch):
"""Test function with a very large string value."""
bigstr = "x" * 1000
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_APP_TITLE", bigstr)
codeflash_output = overloads_from_env(); config = codeflash_output # 13.3μs -> 13.1μs (1.83% faster)

def test_many_valid_overrides(monkeypatch):
"""Set all fields to non-defaults at once."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_WIDTH", "full")
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_APP_TITLE", "Big App")
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_LAYOUT_FILE", "layout.json")
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_CSS_FILE", "css.css")
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_HTML_HEAD_FILE", "head.html")
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_AUTO_DOWNLOAD", "[html,md,pdf]")
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_SQL_OUTPUT", "csv")
codeflash_output = overloads_from_env(); config = codeflash_output # 22.4μs -> 20.2μs (11.1% faster)

def test_env_var_with_non_ascii(monkeypatch):
"""Test non-ASCII characters in env var value."""
monkeypatch.setenv("_MARIMO_APP_OVERLOAD_APP_TITLE", "Mårïmø 🚀")
codeflash_output = overloads_from_env(); config = codeflash_output # 13.7μs -> 13.4μs (2.96% faster)

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

#------------------------------------------------
from marimo._ast.app_config import overloads_from_env

def test_overloads_from_env():
overloads_from_env()

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_bps3n5s8/tmp6garfwr7/test_concolic_coverage.py::test_overloads_from_env	9.86μs	10.9μs	-9.64%⚠️

To edit these changes git checkout codeflash/optimize-overloads_from_env-mhvkvptu and push.