⚡️ Speed up function _del_none_or_empty by 10%

[codeflash-ai]

📄 10% (0.10x) speedup for _del_none_or_empty in marimo/_server/templates/templates.py

⏱️ Runtime : 588 microseconds → 532 microseconds (best of 250 runs)

📝 Explanation and details

The optimization transforms a dictionary comprehension into an explicit loop with early filtering, resulting in a 10% performance improvement.

Key changes:

• Replaced dictionary comprehension with explicit for loop and result dictionary
• Moved the filtering condition (value is not None and value != []) to the beginning of the loop body
• Only processes values that pass the filter, avoiding unnecessary recursive calls and isinstance checks

Why it's faster:
Dictionary comprehensions in Python create the entire key-value mapping before filtering, meaning all values are processed regardless of whether they'll be included. The optimized version uses early filtering - it checks the condition first and only performs expensive operations (recursive calls, type checks) on values that will actually be kept in the result.

Performance benefits by test case type:

• Small dictionaries with many removals (8-21% faster): Significant savings from avoiding unnecessary processing of filtered-out values
• Large nested structures (16-32% faster): Exponential savings as early filtering prevents deep recursion on branches that would be discarded
• Large flat dictionaries (slight regression): The overhead of the explicit loop structure slightly outweighs benefits when most values are kept

The optimization is particularly effective for nested dictionaries with sparse valid data, where avoiding unnecessary recursive traversals provides substantial performance gains. For dense dictionaries with few removals, the performance difference is minimal but still positive overall.

✅ 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 typing import Any

imports

import pytest # used for our unit tests
from marimo._server.templates.templates import _del_none_or_empty

unit tests

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

def test_basic_removal_none_and_empty_list():
# Should remove keys with None or empty list values
input_dict = {
"a": 1,
"b": None,
"c": [],
"d": "hello",
"e": [1, 2, 3]
}
expected = {
"a": 1,
"d": "hello",
"e": [1, 2, 3]
}
codeflash_output = _del_none_or_empty(input_dict) # 1.74μs -> 1.60μs (8.61% faster)

def test_basic_no_removal_needed():
# Should not remove any keys if none are None or empty list
input_dict = {
"x": 0,
"y": [1],
"z": {"a": 1}
}
expected = input_dict.copy()
codeflash_output = _del_none_or_empty(input_dict) # 2.40μs -> 2.03μs (18.1% faster)

def test_basic_all_none_and_empty():
# Should return empty dict if all values are None or empty list
input_dict = {"a": None, "b": [], "c": None}
expected = {}
codeflash_output = _del_none_or_empty(input_dict) # 1.06μs -> 951ns (11.7% faster)

def test_basic_nested_dict_removal():
# Should remove None and [] from nested dicts
input_dict = {
"a": {
"b": None,
"c": [],
"d": 2
},
"e": None,
"f": []
}
expected = {
"a": {"d": 2}
}
codeflash_output = _del_none_or_empty(input_dict) # 2.25μs -> 1.99μs (13.0% faster)

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

def test_edge_empty_dict():
# Should return empty dict if input is empty
input_dict = {}
expected = {}
codeflash_output = _del_none_or_empty(input_dict) # 733ns -> 640ns (14.5% faster)

def test_edge_dict_with_only_none_and_empty_list():
# Should return empty dict
input_dict = {"a": None, "b": [], "c": []}
expected = {}
codeflash_output = _del_none_or_empty(input_dict) # 1.05μs -> 993ns (5.34% faster)

def test_edge_dict_with_empty_string_and_zero():
# Should NOT remove empty string or zero
input_dict = {"a": "", "b": 0, "c": None, "d": []}
expected = {"a": "", "b": 0}
codeflash_output = _del_none_or_empty(input_dict) # 1.50μs -> 1.41μs (6.39% faster)

def test_edge_nested_dict_all_removed():
# Nested dict becomes empty and should be retained
input_dict = {
"outer": {
"inner": {
"x": None,
"y": []
}
}
}
# "inner" becomes empty, but the function retains empty dicts
expected = {
"outer": {
"inner": {}
}
}
codeflash_output = _del_none_or_empty(input_dict) # 2.32μs -> 1.95μs (19.0% faster)

def test_edge_dict_with_tuple_and_set():
# Should not remove tuple or set, even if empty
input_dict = {
"a": (),
"b": set(),
"c": [],
"d": None
}
expected = {
"a": (),
"b": set()
}
codeflash_output = _del_none_or_empty(input_dict) # 1.78μs -> 1.83μs (3.16% slower)

def test_edge_dict_with_false_and_true():
# Should not remove boolean values
input_dict = {
"a": False,
"b": True,
"c": None,
"d": []
}
expected = {"a": False, "b": True}
codeflash_output = _del_none_or_empty(input_dict) # 1.74μs -> 1.66μs (4.89% faster)

def test_edge_dict_with_list_of_none_and_empty():
# Should not remove lists containing None or empty lists, only empty lists themselves
input_dict = {
"a": [None, []],
"b": [],
"c": None
}
expected = {"a": [None, []]}
codeflash_output = _del_none_or_empty(input_dict) # 1.35μs -> 1.20μs (12.1% faster)

def test_edge_dict_with_nested_empty_dict():
# Should retain empty dicts as values
input_dict = {
"a": {},
"b": None,
"c": []
}
expected = {"a": {}}
codeflash_output = _del_none_or_empty(input_dict) # 1.94μs -> 1.64μs (18.3% faster)

def test_edge_dict_with_multiple_types():
# Should only remove None and empty lists, not other falsy values
input_dict = {
"a": "",
"b": 0,
"c": [],
"d": None,
"e": {},
"f": False
}
expected = {
"a": "",
"b": 0,
"e": {},
"f": False
}
codeflash_output = _del_none_or_empty(input_dict) # 2.61μs -> 2.49μs (4.70% faster)

def test_edge_dict_with_nested_dicts_and_lists():
# Should recurse into nested dicts, but not into lists
input_dict = {
"a": {"b": None, "c": []},
"d": [{"e": None}, {"f": []}],
"g": None
}
expected = {
"a": {},
"d": [{"e": None}, {"f": []}]
}
codeflash_output = _del_none_or_empty(input_dict) # 2.22μs -> 1.88μs (17.9% faster)

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

def test_large_flat_dict():
# Large flat dict with alternating None, empty list, and valid values
N = 1000
input_dict = {f"key_{i}": None if i % 3 == 0 else ([] if i % 3 == 1 else i) for i in range(N)}
expected = {f"key_{i}": i for i in range(N) if i % 3 == 2}
codeflash_output = _del_none_or_empty(input_dict) # 46.5μs -> 47.5μs (2.09% slower)

def test_large_nested_dict():
# Large nested dict with some keys to be removed
N = 500
input_dict = {
f"outer_{i}": {
f"inner_{j}": None if (i + j) % 4 == 0 else ([] if (i + j) % 4 == 1 else i + j)
for j in range(5)
}
for i in range(N)
}
expected = {
f"outer_{i}": {
f"inner_{j}": i + j
for j in range(5)
if (i + j) % 4 >= 2
}
for i in range(N)
}
codeflash_output = _del_none_or_empty(input_dict) # 301μs -> 258μs (16.8% faster)

def test_large_dict_with_deep_nesting():
# Deeply nested dicts, some levels become empty
N = 50
input_dict = {
"level1": {
f"level2_{i}": {
"level3": {
"remove_none": None,
"remove_empty": [],
"keep": i
}
} for i in range(N)
}
}
expected = {
"level1": {
f"level2_{i}": {
"level3": {
"keep": i
}
} for i in range(N)
}
}
codeflash_output = _del_none_or_empty(input_dict) # 38.0μs -> 30.8μs (23.5% faster)

def test_large_dict_with_mixed_types():
# Large dict with mixed types, only None and [] should be removed
N = 300
input_dict = {
f"k_{i}": None if i % 5 == 0 else ([] if i % 5 == 1 else ("" if i % 5 == 2 else (0 if i % 5 == 3 else [i])))
for i in range(N)
}
expected = {
f"k_{i}": "" if i % 5 == 2 else (0 if i % 5 == 3 else [i])
for i in range(N)
if i % 5 not in [0, 1]
}
codeflash_output = _del_none_or_empty(input_dict) # 21.7μs -> 22.2μs (1.85% slower)

def test_large_dict_with_lists_of_dicts():
# Should not recurse into lists, only dicts
N = 100
input_dict = {
"data": [
{"a": None, "b": [], "c": i} for i in range(N)
],
"remove_none": None,
"remove_empty": []
}
expected = {
"data": [
{"a": None, "b": [], "c": i} for i in range(N)
]
}
codeflash_output = _del_none_or_empty(input_dict) # 1.44μs -> 1.26μs (13.9% faster)

------------------ Mutation Testing Guards ------------------

def test_mutation_guard_removal_of_empty_lists_only():
# If function is mutated to remove only empty lists, this should fail
input_dict = {"a": None, "b": [], "c": 1}
expected = {"c": 1}
codeflash_output = _del_none_or_empty(input_dict) # 1.35μs -> 1.27μs (6.13% faster)

def test_mutation_guard_removal_of_none_only():
# If function is mutated to remove only None, this should fail
input_dict = {"a": None, "b": [], "c": 1}
expected = {"c": 1}
codeflash_output = _del_none_or_empty(input_dict) # 1.32μs -> 1.20μs (9.97% faster)

def test_mutation_guard_removal_of_other_falsy_values():
# If function is mutated to remove other falsy values, this should fail
input_dict = {"a": "", "b": 0, "c": None, "d": [], "e": False}
expected = {"a": "", "b": 0, "e": False}
codeflash_output = _del_none_or_empty(input_dict) # 1.87μs -> 1.84μs (1.52% faster)

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

#------------------------------------------------
import pytest # used for our unit tests
from marimo._server.templates.templates import _del_none_or_empty

unit tests

----------------------

1. Basic Test Cases

----------------------

def test_basic_removal_none_and_empty_list():
# Should remove keys with None and empty list values
inp = {'a': None, 'b': [], 'c': 1, 'd': 'foo'}
expected = {'c': 1, 'd': 'foo'}
codeflash_output = _del_none_or_empty(inp) # 1.81μs -> 1.62μs (12.0% faster)

def test_basic_dict_with_no_none_or_empty():
# Should leave dict unchanged if no None or []
inp = {'x': 5, 'y': 'bar', 'z': [1,2]}
expected = {'x': 5, 'y': 'bar', 'z': [1,2]}
codeflash_output = _del_none_or_empty(inp) # 1.59μs -> 1.47μs (8.10% faster)

def test_basic_nested_dict():
# Should recursively remove None/[] in nested dicts
inp = {'a': {'b': None, 'c': 2}, 'd': []}
expected = {'a': {'c': 2}}
codeflash_output = _del_none_or_empty(inp) # 2.25μs -> 1.98μs (13.4% faster)

def test_basic_empty_dict():
# Should return empty dict unchanged
inp = {}
expected = {}
codeflash_output = _del_none_or_empty(inp) # 793ns -> 655ns (21.1% faster)

def test_basic_dict_with_false_and_zero():
# Should NOT remove keys with False or 0 values
inp = {'a': False, 'b': 0, 'c': None, 'd': []}
expected = {'a': False, 'b': 0}
codeflash_output = _del_none_or_empty(inp) # 1.84μs -> 1.69μs (8.68% faster)

----------------------

2. Edge Test Cases

----------------------

def test_edge_dict_with_only_none_and_empty():
# Should return empty dict if all values are None or []
inp = {'x': None, 'y': [], 'z': None}
expected = {}
codeflash_output = _del_none_or_empty(inp) # 1.04μs -> 973ns (6.99% faster)

def test_edge_dict_with_empty_string_and_empty_tuple():
# Should NOT remove keys with empty string or tuple
inp = {'a': '', 'b': (), 'c': None, 'd': []}
expected = {'a': '', 'b': ()}
codeflash_output = _del_none_or_empty(inp) # 1.77μs -> 1.69μs (4.99% faster)

def test_edge_dict_with_nested_empty_dict():
# Should NOT remove keys with empty dict as value
inp = {'a': {}, 'b': None, 'c': []}
expected = {'a': {}}
codeflash_output = _del_none_or_empty(inp) # 1.98μs -> 1.74μs (13.9% faster)

def test_edge_dict_with_various_empty_iterables():
# Should only remove empty list, not other empty iterables
inp = {'a': [], 'b': (), 'c': {}, 'd': set(), 'e': None}
expected = {'b': (), 'c': {}, 'd': set()}
codeflash_output = _del_none_or_empty(inp) # 2.62μs -> 2.54μs (3.27% faster)

def test_edge_dict_with_list_containing_none_and_empty():
# Should NOT remove key if value is a list containing None/[]
inp = {'a': [None, []], 'b': None, 'c': []}
expected = {'a': [None, []]}
codeflash_output = _del_none_or_empty(inp) # 1.33μs -> 1.21μs (10.5% faster)

def test_edge_nested_dict_all_removed():
# Should remove all keys in nested dict if all values are None or []
inp = {'a': {'x': None, 'y': []}, 'b': None}
expected = {'a': {}}
codeflash_output = _del_none_or_empty(inp) # 1.92μs -> 1.69μs (13.7% faster)

def test_edge_nested_dict_some_removed():
# Should only remove keys with None/[] in nested dict
inp = {'a': {'x': 1, 'y': None, 'z': []}, 'b': 2}
expected = {'a': {'x': 1}, 'b': 2}
codeflash_output = _del_none_or_empty(inp) # 2.27μs -> 1.96μs (16.2% faster)

def test_edge_dict_with_non_dict_input():
# Should raise AttributeError if input is not a dict
with pytest.raises(AttributeError):
_del_none_or_empty([1,2,3]) # 1.26μs -> 1.19μs (6.41% faster)

def test_edge_dict_with_non_hashable_keys():
# Should work with any hashable keys, including numbers and tuples
inp = {1: None, (2,3): [], 'a': 5}
expected = {'a': 5}
codeflash_output = _del_none_or_empty(inp) # 1.40μs -> 1.29μs (8.60% faster)

def test_edge_dict_with_boolean_keys():
# Should work with boolean keys
inp = {True: None, False: [], 'ok': 'yes'}
expected = {'ok': 'yes'}
codeflash_output = _del_none_or_empty(inp) # 1.36μs -> 1.24μs (9.52% faster)

def test_edge_dict_with_none_key():
# Should work with None as a key (only value matters)
inp = {None: 'foo', 'bar': None}
expected = {None: 'foo'}
codeflash_output = _del_none_or_empty(inp) # 1.26μs -> 1.14μs (10.9% faster)

def test_edge_dict_with_custom_object_as_value():
# Should not remove custom object values
class Dummy: pass
obj = Dummy()
inp = {'a': obj, 'b': None, 'c': []}
expected = {'a': obj}
codeflash_output = _del_none_or_empty(inp) # 1.54μs -> 1.46μs (5.63% faster)

def test_edge_dict_with_nested_empty_dict_removed():
# Should keep keys whose value is an empty dict (not removed)
inp = {'a': {}, 'b': None}
expected = {'a': {}}
codeflash_output = _del_none_or_empty(inp) # 1.81μs -> 1.51μs (19.4% faster)

def test_edge_dict_with_nested_dict_with_only_none_and_empty():
# Should reduce nested dict to empty dict if all values removed
inp = {'a': {'b': None, 'c': []}}
expected = {'a': {}}
codeflash_output = _del_none_or_empty(inp) # 1.84μs -> 1.65μs (11.9% faster)

def test_edge_dict_with_deeply_nested_dict():
# Should recursively remove None/[] at all depths
inp = {'a': {'b': {'c': None, 'd': []}, 'e': 1}, 'f': []}
expected = {'a': {'b': {}, 'e': 1}}
codeflash_output = _del_none_or_empty(inp) # 2.58μs -> 2.15μs (20.1% faster)

def test_edge_dict_with_list_of_dicts():
# Should NOT recurse into lists of dicts
inp = {'a': [{'b': None}, {'c': []}], 'd': None}
expected = {'a': [{'b': None}, {'c': []}]}
codeflash_output = _del_none_or_empty(inp) # 1.16μs -> 1.05μs (10.3% faster)

----------------------

3. Large Scale Test Cases

----------------------

def test_large_dict_many_none_and_empty():
# Large dict with many None and [] values
N = 1000
inp = {f'key{i}': None if i % 2 == 0 else [] if i % 3 == 0 else i for i in range(N)}
expected = {f'key{i}': i for i in range(N) if i % 2 != 0 and i % 3 != 0}
codeflash_output = _del_none_or_empty(inp) # 44.5μs -> 46.5μs (4.31% slower)

def test_large_nested_dict():
# Large nested dict, each subdict has some None/[]
N = 100
inp = {f'outer{i}': {f'inner{j}': None if j % 2 == 0 else [] if j % 3 == 0 else j for j in range(N)} for i in range(10)}
expected = {f'outer{i}': {f'inner{j}': j for j in range(N) if j % 2 != 0 and j % 3 != 0} for i in range(10)}
codeflash_output = _del_none_or_empty(inp) # 47.2μs -> 46.9μs (0.734% faster)

def test_large_dict_with_large_list_values():
# Should not remove large non-empty lists
N = 500
inp = {'a': list(range(N)), 'b': [], 'c': None}
expected = {'a': list(range(N))}
codeflash_output = _del_none_or_empty(inp) # 1.36μs -> 1.28μs (5.76% faster)

def test_large_dict_with_mixed_types():
# Large dict with mixed types, only None/[] removed
N = 200
inp = {i: None if i % 5 == 0 else [] if i % 7 == 0 else str(i) if i % 2 == 0 else i for i in range(N)}
expected = {i: str(i) if i % 2 == 0 else i for i in range(N) if i % 5 != 0 and i % 7 != 0}
codeflash_output = _del_none_or_empty(inp) # 15.0μs -> 15.1μs (0.093% slower)

def test_large_dict_with_deep_nesting():
# Deeply nested dict, each level has some None/[]
N = 10
def make_deep(n):
if n == 0:
return {'a': None, 'b': []}
return {'a': make_deep(n-1), 'b': None, 'c': []}
inp = make_deep(N)
# At each level, only 'a' remains, but its value is a dict with only 'a'
def expected_deep(n):
if n == 0:
return {}
return {'a': expected_deep(n-1)}
expected = expected_deep(N)
codeflash_output = _del_none_or_empty(inp) # 5.65μs -> 4.28μs (32.0% 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._server.templates.templates import _del_none_or_empty
import pytest

def test__del_none_or_empty():
with pytest.raises(AttributeError, match="'SymbolicInt'\ object\ has\ no\ attribute\ 'items'"):
_del_none_or_empty(0)

To edit these changes git checkout codeflash/optimize-_del_none_or_empty-mhu3r0k3 and push.