⚡️ Speed up method _BackupLocationConfig._to_dict by 857%

[codeflash-ai]

📄 857% (8.57x) speedup for _BackupLocationConfig._to_dict in weaviate/backup/backup_location.py

⏱️ Runtime : 230 microseconds → 24.0 microseconds (best of 98 runs)

📝 Explanation and details

The optimization replaces Pydantic's model_dump(exclude_none=True) method with a direct dictionary comprehension that filters out None values from self.__dict__. This achieves an 856% speedup by eliminating the overhead of Pydantic's serialization machinery.

Key changes:

• Removed model_dump() call: Pydantic's model_dump() performs validation, type checking, and handles complex serialization scenarios, which adds significant overhead for simple field access
• Direct __dict__ access: Uses {k: v for k, v in self.__dict__.items() if v is not None} to directly access the instance's attribute dictionary and filter out None values
• Removed unnecessary cast(): The dictionary comprehension already returns the correct type

Why this is faster:
Pydantic's model_dump() is designed for complex serialization scenarios (nested models, custom serializers, aliases, etc.) but comes with substantial overhead. For simple filtering of None values, direct dictionary access bypasses all this machinery and operates at native Python speed.

Test case performance:
The optimization excels across all scenarios:

• Simple models (1-4 fields): ~380-420% faster
• Empty models: ~450% faster
• Complex field types (lists, dicts, sets): ~390-500% faster
• Large models (300+ items): Up to 3715% faster

This optimization is particularly effective for models with simple field types that don't require Pydantic's advanced serialization features, which appears to be the primary use case based on the test results.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Any, Dict, cast

# imports
import pytest  # used for our unit tests
from pydantic import BaseModel
from weaviate.backup.backup_location import _BackupLocationConfig

# unit tests

# 1. Basic Test Cases

def test_basic_single_field():
    # Test with a simple model with one field
    class TestConfig(_BackupLocationConfig):
        name: str

    obj = TestConfig(name="backup1")
    codeflash_output = obj._to_dict(); result = codeflash_output # 5.40μs -> 1.04μs (418% faster)

def test_basic_multiple_fields():
    # Test with multiple fields of different types
    class TestConfig(_BackupLocationConfig):
        name: str
        size: int
        active: bool

    obj = TestConfig(name="backup2", size=100, active=True)
    codeflash_output = obj._to_dict(); result = codeflash_output # 5.60μs -> 1.17μs (381% faster)

def test_basic_default_values():
    # Test with default values (should be included if not None)
    class TestConfig(_BackupLocationConfig):
        name: str = "default"
        size: int = 10

    obj = TestConfig()
    codeflash_output = obj._to_dict(); result = codeflash_output # 5.30μs -> 1.09μs (384% faster)

def test_basic_none_field_excluded():
    # Test that fields set to None are excluded
    class TestConfig(_BackupLocationConfig):
        name: str
        description: str = None

    obj = TestConfig(name="backup3")
    codeflash_output = obj._to_dict(); result = codeflash_output # 5.21μs -> 1.08μs (382% faster)

# 2. Edge Test Cases

def test_edge_empty_model():
    # Test with an empty model (no fields)
    class TestConfig(_BackupLocationConfig):
        pass

    obj = TestConfig()
    codeflash_output = obj._to_dict(); result = codeflash_output # 4.47μs -> 813ns (450% faster)

def test_edge_all_none_fields():
    # Test with all fields set to None
    class TestConfig(_BackupLocationConfig):
        a: str = None
        b: int = None

    obj = TestConfig()
    codeflash_output = obj._to_dict(); result = codeflash_output # 4.67μs -> 1.03μs (353% faster)


def test_edge_list_and_dict_fields():
    # Test with list and dict fields containing None values
    class TestConfig(_BackupLocationConfig):
        items: list
        mapping: dict

    obj = TestConfig(items=[1, None, 3], mapping={"a": 1, "b": None})
    codeflash_output = obj._to_dict(); result = codeflash_output # 6.83μs -> 1.14μs (498% faster)

def test_edge_field_with_false_zero_empty():
    # Test with fields set to False, 0, and empty string (should not be excluded)
    class TestConfig(_BackupLocationConfig):
        flag: bool
        count: int
        text: str

    obj = TestConfig(flag=False, count=0, text="")
    codeflash_output = obj._to_dict(); result = codeflash_output # 5.56μs -> 1.13μs (391% faster)

def test_edge_field_with_empty_list_dict():
    # Test with empty list and dict fields (should not be excluded)
    class TestConfig(_BackupLocationConfig):
        items: list
        mapping: dict

    obj = TestConfig(items=[], mapping={})
    codeflash_output = obj._to_dict(); result = codeflash_output # 5.44μs -> 1.10μs (393% faster)

def test_edge_field_with_complex_types():
    # Test with complex types (tuple, set, frozenset)
    class TestConfig(_BackupLocationConfig):
        tup: tuple
        st: set
        fst: frozenset

    obj = TestConfig(tup=(1, 2), st={3, 4}, fst=frozenset([5, 6]))
    codeflash_output = obj._to_dict(); result = codeflash_output # 7.32μs -> 1.21μs (505% faster)

def test_edge_field_with_bytes():
    # Test with bytes field
    class TestConfig(_BackupLocationConfig):
        data: bytes

    obj = TestConfig(data=b"abc")
    codeflash_output = obj._to_dict(); result = codeflash_output # 4.81μs -> 1.02μs (370% faster)

# 3. Large Scale Test Cases




def test_large_list_of_dicts():
    # Test with a large list of dictionaries
    class TestConfig(_BackupLocationConfig):
        items: list

    items = [{"a": i, "b": None} for i in range(300)]
    obj = TestConfig(items=items)
    codeflash_output = obj._to_dict(); result = codeflash_output # 43.0μs -> 1.13μs (3715% faster)
    for i, d in enumerate(result["items"]):
        pass


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

# imports
import pytest  # used for our unit tests
from pydantic import BaseModel
from weaviate.backup.backup_location import _BackupLocationConfig

# unit tests

# 1. Basic Test Cases

def test_to_dict_simple_fields():
    # Test with simple fields
    class SimpleConfig(_BackupLocationConfig):
        name: str
        size: int

    cfg = SimpleConfig(name="backup1", size=42)
    codeflash_output = cfg._to_dict(); result = codeflash_output # 5.47μs -> 1.07μs (411% faster)


def test_to_dict_multiple_types():
    # Test with multiple types
    class MultiTypeConfig(_BackupLocationConfig):
        a: int
        b: float
        c: str
        d: bool

    cfg = MultiTypeConfig(a=1, b=2.5, c="hello", d=True)
    codeflash_output = cfg._to_dict(); result = codeflash_output # 5.90μs -> 1.24μs (375% faster)

# 2. Edge Test Cases

def test_to_dict_empty_model():
    # Test with no fields
    class EmptyConfig(_BackupLocationConfig):
        pass

    cfg = EmptyConfig()
    codeflash_output = cfg._to_dict(); result = codeflash_output # 4.23μs -> 826ns (413% faster)



def test_to_dict_list_and_dict_fields():
    # Test with list and dict fields
    class ListDictConfig(_BackupLocationConfig):
        items: list
        mapping: dict

    cfg = ListDictConfig(items=[1, 2, 3], mapping={"a": 1, "b": 2})
    codeflash_output = cfg._to_dict(); result = codeflash_output # 6.66μs -> 1.13μs (489% faster)

def test_to_dict_field_with_falsey_values():
    # Test with fields that are falsey but not None
    class FalseyConfig(_BackupLocationConfig):
        zero: int
        empty_str: str
        empty_list: list

    cfg = FalseyConfig(zero=0, empty_str="", empty_list=[])
    codeflash_output = cfg._to_dict(); result = codeflash_output # 6.00μs -> 1.19μs (406% faster)

def test_to_dict_field_with_default_values():
    # Test with fields that have default values
    class DefaultConfig(_BackupLocationConfig):
        a: int = 10
        b: str = "default"

    cfg = DefaultConfig()
    codeflash_output = cfg._to_dict(); result = codeflash_output # 5.27μs -> 1.12μs (372% faster)

def test_to_dict_field_with_optional_type():
    # Test with Optional type fields
    from typing import Optional

    class OptionalConfig(_BackupLocationConfig):
        a: Optional[int]
        b: Optional[str]

    cfg = OptionalConfig(a=None, b="present")
    codeflash_output = cfg._to_dict(); result = codeflash_output # 5.50μs -> 1.08μs (411% faster)

# 3. Large Scale Test Cases




def test_to_dict_performance_large_model():
    # Test performance/scalability with a large model
    import time

    class PerfConfig(_BackupLocationConfig):
        pass

    # Dynamically add fields
    for i in range(900):
        setattr(PerfConfig, f"field_{i}", (int, ...))

    values = {f"field_{i}": i for i in range(900)}
    cfg = PerfConfig(**values)
    start = time.time()
    codeflash_output = cfg._to_dict(); result = codeflash_output # 5.11μs -> 1.08μs (373% 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 weaviate.backup.backup_location import _BackupLocationConfig

def test__BackupLocationConfig__to_dict():
    _BackupLocationConfig._to_dict(_BackupLocationConfig())

Timer unit: 1e-09 s

To edit these changes git checkout codeflash/optimize-_BackupLocationConfig._to_dict-mh32m6j3 and push.