⚡️ Speed up method DefaultDependency.as_dict by 19%

[codeflash-ai]

📄 19% (0.19x) speedup for DefaultDependency.as_dict in src/titiler/core/titiler/core/dependencies.py

⏱️ Runtime : 61.8 microseconds → 52.1 microseconds (best of 250 runs)

📝 Explanation and details

The optimization replaces a dictionary comprehension with an explicit loop and adds local variable caching. Here's why it's faster:

Key Optimizations:

1. Eliminated dictionary comprehension overhead: The original {k: v for k, v in self.__dict__.items() if v is not None} creates intermediate generator objects and has additional Python bytecode overhead. The explicit loop with pre-allocated dictionary (out = {}) avoids this overhead.

2. Cached attribute lookup: self.__dict__ is stored in local variable d to avoid repeated attribute lookups in both the exclude_none and non-exclude branches.

Performance Analysis:
The line profiler shows the dictionary comprehension in the original code took 68.5% of total execution time (99,295ns per hit). The optimized version distributes this work across simpler operations: the loop iteration (28.9%), None checks (8.9%), and dictionary assignments (7.8%), resulting in better CPU cache usage and reduced interpreter overhead.

Test Case Performance:

• Small dataclasses: 12-25% speedup across basic test cases
• Large dataclasses: 28-40% speedup for cases with 1000+ fields, particularly when many fields are None
• Mixed scenarios: 15-33% improvement when half the fields contain None values

Workload Impact:
This optimization is especially beneficial for:

• Applications processing many dataclass instances with optional fields
• Large dataclasses where field filtering is common
• High-frequency serialization workflows where as_dict() is called repeatedly

The explicit loop approach scales better with dictionary size, making it particularly valuable for complex dataclass structures.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

🌀 Generated Regression Tests and Runtime

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

# imports
import pytest
from titiler.core.dependencies import DefaultDependency

# --- UNIT TESTS ---

# Basic Test Cases

def test_as_dict_basic_with_no_fields():
    # Test: dataclass with no fields
    dep = DefaultDependency()
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.16μs -> 925ns (25.1% faster)

def test_as_dict_basic_with_fields_and_values():
    # Test: dataclass with fields and values
    @dataclass
    class MyDep(DefaultDependency):
        a: int = 1
        b: str = "foo"
        c: float = 2.5

    dep = MyDep()
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.67μs -> 1.46μs (14.6% faster)

def test_as_dict_basic_with_fields_and_none_values():
    # Test: dataclass with some fields set to None
    @dataclass
    class MyDep(DefaultDependency):
        a: int = 1
        b: Optional[str] = None
        c: float = 2.5

    dep = MyDep()
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.55μs -> 1.38μs (12.5% faster)
    # Test with exclude_none=False
    codeflash_output = dep.as_dict(exclude_none=False); result = codeflash_output # 1.18μs -> 1.03μs (14.3% faster)

def test_as_dict_basic_with_all_none_fields():
    # Test: dataclass with all fields None
    @dataclass
    class MyDep(DefaultDependency):
        a: Optional[int] = None
        b: Optional[str] = None

    dep = MyDep()
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.43μs -> 1.23μs (16.3% faster)
    codeflash_output = dep.as_dict(exclude_none=False); result = codeflash_output # 1.15μs -> 965ns (19.0% faster)

# Edge Test Cases

def test_as_dict_edge_with_various_types():
    # Test: dataclass with various types, including mutable types
    @dataclass
    class MyDep(DefaultDependency):
        a: list = field(default_factory=lambda: [1, 2])
        b: dict = field(default_factory=lambda: {'x': 10})
        c: Any = None

    dep = MyDep()
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.70μs -> 1.42μs (19.3% faster)
    codeflash_output = dep.as_dict(exclude_none=False); result = codeflash_output # 1.10μs -> 975ns (13.0% faster)

def test_as_dict_edge_with_false_zero_empty_values():
    # Test: dataclass with False, 0, '', [], {}, which are not None
    @dataclass
    class MyDep(DefaultDependency):
        a: bool = False
        b: int = 0
        c: str = ''
        d: list = field(default_factory=list)
        e: dict = field(default_factory=dict)
        f: None = None

    dep = MyDep()
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.81μs -> 1.60μs (13.6% faster)
    codeflash_output = dep.as_dict(exclude_none=False); result = codeflash_output # 1.31μs -> 1.05μs (24.0% faster)

def test_as_dict_edge_with_private_and_dunder_fields():
    # Test: dataclass with private and dunder fields
    @dataclass
    class MyDep(DefaultDependency):
        a: int = 1
        _private: str = "secret"
        __dunder: str = "hidden"

    dep = MyDep()
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.65μs -> 1.39μs (19.1% faster)
    # __dunder will be name-mangled in __dict__ as _MyDep__dunder
    expected_keys = {'a', '_private', '_MyDep__dunder'}

def test_as_dict_edge_with_field_set_to_none_after_init():
    # Test: set a field to None after initialization
    @dataclass
    class MyDep(DefaultDependency):
        a: int = 1
        b: int = 2

    dep = MyDep()
    dep.b = None
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.55μs -> 1.28μs (20.6% faster)
    codeflash_output = dep.as_dict(exclude_none=False); result = codeflash_output # 1.13μs -> 1.01μs (12.1% faster)

def test_as_dict_edge_with_dynamic_attributes():
    # Test: adding attributes dynamically
    dep = DefaultDependency()
    dep.foo = 123
    dep.bar = None
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.40μs -> 1.15μs (21.7% faster)
    codeflash_output = dep.as_dict(exclude_none=False); result = codeflash_output # 1.03μs -> 949ns (8.43% faster)

# Large Scale Test Cases

def test_as_dict_large_scale_many_fields():
    # Test: dataclass with many fields (up to 1000)
    fields = {f'field_{i}': i for i in range(1000)}
    # Dynamically create dataclass with many fields
    MyDep = dataclass(type('MyDep', (DefaultDependency,), fields))
    dep = MyDep()
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.28μs -> 999ns (28.5% faster)
    expected = {f'field_{i}': i for i in range(1000)}

def test_as_dict_large_scale_many_none_fields():
    # Test: dataclass with many fields, all set to None
    fields = {f'field_{i}': None for i in range(1000)}
    MyDep = dataclass(type('MyDep', (DefaultDependency,), fields))
    dep = MyDep()
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.31μs -> 1.05μs (25.1% faster)
    codeflash_output = dep.as_dict(exclude_none=False); result = codeflash_output # 1.02μs -> 729ns (39.9% faster)
    expected = {f'field_{i}': None for i in range(1000)}

def test_as_dict_large_scale_mixed_fields():
    # Test: dataclass with half fields None, half with values
    fields = {}
    for i in range(1000):
        if i % 2 == 0:
            fields[f'field_{i}'] = i
        else:
            fields[f'field_{i}'] = None
    MyDep = dataclass(type('MyDep', (DefaultDependency,), fields))
    dep = MyDep()
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.36μs -> 1.02μs (33.1% faster)
    expected = {f'field_{i}': i for i in range(0, 1000, 2)}
    codeflash_output = dep.as_dict(exclude_none=False); result = codeflash_output # 1.06μs -> 775ns (36.6% faster)
    expected = {f'field_{i}': (i if i % 2 == 0 else None) for i in range(1000)}

def test_as_dict_performance_large_scale():
    # Performance: ensure as_dict runs quickly for large dataclasses
    import time
    fields = {f'field_{i}': i for i in range(1000)}
    MyDep = dataclass(type('MyDep', (DefaultDependency,), fields))
    dep = MyDep()
    start = time.time()
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.33μs -> 1.04μs (27.6% faster)
    duration = time.time() - start
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional

# imports
import pytest
from titiler.core.dependencies import DefaultDependency

# --- Test Classes for more complex scenarios ---
@dataclass
class SimpleDep(DefaultDependency):
    a: int
    b: str

@dataclass
class OptionalDep(DefaultDependency):
    a: Optional[int] = None
    b: Optional[str] = None
    c: Optional[float] = None

@dataclass
class MixedDep(DefaultDependency):
    a: int
    b: Optional[str] = None
    c: float = 1.23

@dataclass
class NestedDep(DefaultDependency):
    a: int
    b: DefaultDependency

@dataclass
class ListDep(DefaultDependency):
    items: List[Any]
    opt: Optional[int] = None

# --- Unit Tests ---

# 1. Basic Test Cases

def test_as_dict_basic_all_fields_present():
    # Test with all fields present and non-None
    dep = SimpleDep(a=1, b="foo")
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.47μs -> 1.26μs (16.9% faster)

def test_as_dict_basic_exclude_none_false():
    # Test with exclude_none=False; should include all fields, even if None
    dep = OptionalDep(a=1, b=None, c=None)
    codeflash_output = dep.as_dict(exclude_none=False); result = codeflash_output # 1.55μs -> 1.30μs (19.6% faster)

def test_as_dict_basic_exclude_none_true():
    # Test with exclude_none=True; should exclude fields with None values
    dep = OptionalDep(a=1, b=None, c=None)
    codeflash_output = dep.as_dict(exclude_none=True); result = codeflash_output # 1.63μs -> 1.42μs (15.0% faster)

def test_as_dict_basic_default_behavior():
    # Test that default for exclude_none is True
    dep = OptionalDep(a=None, b="bar", c=None)
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.33μs -> 1.25μs (6.38% faster)

def test_as_dict_basic_with_mixed_types():
    # Test with mixed types: int, None, float
    dep = MixedDep(a=5, b=None, c=3.14)
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.36μs -> 1.13μs (20.5% faster)

def test_as_dict_basic_with_empty_string():
    # Test with empty string (should not be excluded)
    dep = SimpleDep(a=0, b="")
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.40μs -> 1.20μs (16.0% faster)

# 2. Edge Test Cases

def test_as_dict_all_fields_none():
    # All fields set to None, exclude_none=True: should return empty dict
    dep = OptionalDep(a=None, b=None, c=None)
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.15μs -> 1.07μs (7.86% faster)

def test_as_dict_all_fields_none_exclude_false():
    # All fields None, exclude_none=False: should return all fields with None
    dep = OptionalDep(a=None, b=None, c=None)
    codeflash_output = dep.as_dict(exclude_none=False); result = codeflash_output # 1.42μs -> 1.33μs (6.99% faster)

def test_as_dict_no_fields():
    # Dataclass with no fields
    @dataclass
    class EmptyDep(DefaultDependency):
        pass
    dep = EmptyDep()
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.30μs -> 1.03μs (25.7% faster)

def test_as_dict_with_nested_dataclass():
    # Nested dataclass as a field
    nested = SimpleDep(a=10, b="baz")
    dep = NestedDep(a=1, b=nested)
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.38μs -> 1.27μs (8.50% faster)

def test_as_dict_with_list_and_none():
    # List field with None value
    dep = ListDep(items=[1, 2, 3], opt=None)
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.39μs -> 1.21μs (15.0% faster)

def test_as_dict_with_list_and_value():
    # List field with value in optional field
    dep = ListDep(items=[], opt=42)
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.45μs -> 1.24μs (16.7% faster)

def test_as_dict_with_false_and_zero():
    # Fields with False and 0 (should not be excluded)
    @dataclass
    class BoolDep(DefaultDependency):
        flag: bool
        count: int
        none_field: Optional[int] = None
    dep = BoolDep(flag=False, count=0)
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.65μs -> 1.39μs (18.8% faster)

def test_as_dict_with_special_types():
    # Fields with special types (e.g., object, set)
    @dataclass
    class SpecialDep(DefaultDependency):
        obj: object
        s: set
        n: Optional[int] = None
    o = object()
    dep = SpecialDep(obj=o, s={1,2})
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.62μs -> 1.40μs (15.7% faster)

def test_as_dict_with_field_named_none():
    # Field actually named 'none'
    @dataclass
    class WeirdDep(DefaultDependency):
        none: int
        foo: Optional[int] = None
    dep = WeirdDep(none=123)
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.52μs -> 1.29μs (17.5% faster)

def test_as_dict_with_private_and_dunder_fields():
    # Private and dunder fields should not be included (dataclasses don't store them in __dict__)
    @dataclass
    class PrivateDep(DefaultDependency):
        a: int
        _private: int = field(default=5, repr=False)
        __dunder: int = field(default=7, repr=False)
    dep = PrivateDep(a=1)
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.60μs -> 1.38μs (16.5% faster)
    # Only 'a' and '_private' (name-mangled) should appear, not '__dunder'
    # But dataclasses name-mangle __dunder, so it appears as _PrivateDep__dunder
    expected_keys = set(['a', '_private', '_PrivateDep__dunder'])

# 3. Large Scale Test Cases

def test_as_dict_large_number_of_fields_exclude_none_true():
    # Dataclass with 500 fields, half set to None
    fields = {f"f{i}": (int if i % 2 == 0 else Optional[int], None if i % 2 else i) for i in range(500)}
    # Dynamically create dataclass
    namespace = dict(fields)
    LargeDep = dataclass(type("LargeDep", (DefaultDependency,), namespace))
    dep = LargeDep()
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.29μs -> 1.06μs (21.9% faster)
    # Only even fields should be present
    expected = {f"f{i}": i for i in range(0, 500, 2)}

def test_as_dict_large_number_of_fields_exclude_none_false():
    # Dataclass with 500 fields, half set to None
    fields = {f"f{i}": (int if i % 2 == 0 else Optional[int], None if i % 2 else i) for i in range(500)}
    namespace = dict(fields)
    LargeDep = dataclass(type("LargeDep", (DefaultDependency,), namespace))
    dep = LargeDep()
    codeflash_output = dep.as_dict(exclude_none=False); result = codeflash_output # 1.42μs -> 1.17μs (21.4% faster)
    # All fields should be present, with None for odd fields
    expected = {f"f{i}": (i if i % 2 == 0 else None) for i in range(500)}

def test_as_dict_large_list_field():
    # Dataclass with a large list field
    large_list = list(range(1000))
    dep = ListDep(items=large_list)
    codeflash_output = dep.as_dict(); result = codeflash_output # 1.56μs -> 1.33μs (17.4% faster)

from titiler.core.dependencies import DefaultDependency

def test_DefaultDependency_as_dict():
    DefaultDependency.as_dict(DefaultDependency(), exclude_none=True)

def test_DefaultDependency_as_dict_2():
    DefaultDependency.as_dict(DefaultDependency(), exclude_none=False)

🔎 Concolic Coverage Tests and Runtime

To edit these changes git checkout codeflash/optimize-DefaultDependency.as_dict-mifnaa9h and push.