⚡️ Speed up function asdict by 44%

[codeflash-ai]

📄 44% (0.44x) speedup for asdict in src/datasets/utils/py_utils.py

⏱️ Runtime : 8.25 milliseconds → 5.73 milliseconds (best of 5 runs)

📝 Explanation and details

This optimization achieves a 43% runtime improvement (from 8.25ms to 5.73ms) by adding a fast-path for immutable built-in types before the expensive copy.deepcopy() fallback.

Key optimization: A new check if isinstance(obj, (str, bytes, int, float, bool, type(None), complex)) returns these immutable types directly, bypassing copy.deepcopy(). Since these types are immutable, they don't need defensive copying—returning them directly is both safe and significantly faster.

Why this matters:

• copy.deepcopy() involves introspection, recursion guards, memo dictionaries, and type-specific copying logic—expensive overhead for simple immutables
• Test results show dramatic speedups when processing large collections of primitives:
  • 500-element list of integers: 73.1% faster (528μs → 305μs)
  • 500-key dict with string values: 81.3% faster (1.03ms → 569μs)
  • 300-element list of dicts: 47.7% faster (1.55ms → 1.05ms)

Impact on hot paths: Based on function_references, asdict() is called in critical paths like push_to_hub() and save_to_disk() when serializing DatasetInfo objects to JSON metadata. These operations happen during dataset publishing/saving workflows, where datasets often contain many primitive-typed fields (integers for sizes, strings for names, booleans for flags). The optimization directly reduces overhead in these serialization hot paths.

Trade-offs: The optimization adds a tiny overhead (~3-5% slower) for rare edge cases involving mutable objects requiring deepcopy (like sets), but this is negligible compared to the massive gains for common primitive-heavy workloads that dominate real-world usage.

✅ Correctness verification report:

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

⚙️ Click to see Existing Unit Tests

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
features/test_features.py::FeaturesTest.test_class_label_feature_with_no_labels	147μs	131μs	12.1%✅
features/test_features.py::FeaturesTest.test_feature_named_self_as_kwarg	104μs	97.2μs	7.23%✅
features/test_features.py::FeaturesTest.test_feature_named_type	104μs	90.1μs	15.8%✅
features/test_features.py::test_class_label_to_and_from_dict	177μs	151μs	17.0%✅
test_info.py::test_dataset_info_from_dict_with_large_list	42.4μs	32.3μs	31.5%✅
test_py_utils.py::test_asdict	182μs	174μs	4.57%✅
test_splits.py::test_split_dict_asdict_has_dataset_name	69.9μs	57.0μs	22.5%✅

🌀 Click to see Generated Regression Tests

import copy
from collections import namedtuple
from dataclasses import dataclass, field, fields, is_dataclass

# imports
import pytest  # used for our unit tests
from src.datasets.utils.py_utils import asdict

def test_simple_dataclass_omits_default_field():
    # Define a simple dataclass with a default value for 'b'
    @dataclass
    class Simple:
        a: int
        b: int = 0

    s = Simple(a=1, b=0)  # b equals its default and was provided via init
    # Convert to dict - 'b' should be omitted because its value equals the field default
    codeflash_output = asdict(s); d = codeflash_output # 17.4μs -> 16.8μs (3.51% faster)

def test_field_with_init_false_and_metadata_forces_inclusion():
    # Field with init=False should be included even when equal to default
    @dataclass
    class Special:
        x: int = field(init=False, default=0)  # not included in __init__, but should be in asdict
        y: int = 0  # default, init=True -> usually omitted
        z: int = field(default=0, metadata={"include_in_asdict_even_if_is_default": True})

    s = Special()  # x exists as attribute despite init=False
    s.x = 0  # explicit assignment to show equal to default
    # y is default and init-able; z has metadata forcing inclusion
    codeflash_output = asdict(s); d = codeflash_output # 14.6μs -> 11.9μs (23.0% faster)

def test_nested_dataclass_and_namedtuple_inside_dataclass():
    Point = namedtuple("Point", ["x", "y"])

    @dataclass
    class Inner:
        val: int

    @dataclass
    class Outer:
        inner: Inner
        point: Point
        tags: list

    o = Outer(inner=Inner(val=2), point=Point(1, 2), tags=["a", "b"])
    # asdict should recursively convert the nested Inner dataclass to a dict,
    # convert the namedtuple inside the dataclass using the namedtuple branch,
    # and convert lists appropriately.
    codeflash_output = asdict(o); d = codeflash_output # 25.4μs -> 24.0μs (5.77% faster)

def test_dict_top_level_with_nested_dataclass_value():
    @dataclass
    class Item:
        n: int

    # Top-level dicts are accepted by asdict
    input_dict = {"one": Item(n=1)}
    codeflash_output = asdict(input_dict); out = codeflash_output # 15.8μs -> 14.8μs (6.70% faster)

def test_error_on_non_dict_and_non_dataclass_top_level():
    # Passing a plain int should raise TypeError with the expected message fragment
    with pytest.raises(TypeError) as excinfo:
        asdict(5) # 5.54μs -> 4.63μs (19.8% faster)

def test_leaf_mutable_is_deepcopied():
    @dataclass
    class HasSet:
        s: set = field(default_factory=lambda: {1, 2})

    inst = HasSet()
    # Convert - the set is handled by the generic 'else' branch via deepcopy
    codeflash_output = asdict(inst); out = codeflash_output # 21.6μs -> 22.5μs (3.76% slower)

def test_tuple_of_dataclasses_inside_dataclass_is_converted_to_tuple_of_dicts():
    @dataclass
    class Inner:
        value: int

    @dataclass
    class Container:
        items: tuple

    items = (Inner(5), Inner(6))
    c = Container(items=items)
    codeflash_output = asdict(c); out = codeflash_output # 21.3μs -> 19.2μs (10.8% faster)

def test_large_list_of_primitives_conversion_and_identity():
    # Create a dataclass containing a list of 500 integers (keeps under 1000)
    @dataclass
    class Big:
        items: list

    items = list(range(500))
    b = Big(items=items)
    codeflash_output = asdict(b); out = codeflash_output # 528μs -> 305μs (73.1% faster)

def test_large_list_of_dataclasses_conversion_correctness():
    # Create a dataclass with a list of 250 small dataclass elements (keeps <1000)
    @dataclass
    class Elem:
        v: int

    @dataclass
    class Container:
        elems: list

    elems = [Elem(i) for i in range(250)]
    c = Container(elems=elems)
    codeflash_output = asdict(c); out = codeflash_output # 576μs -> 439μs (31.1% faster)

def test_namedtuple_elements_in_list_are_preserved_and_converted_if_needed():
    # Create a namedtuple and place several instances inside a dataclass list
    Point = namedtuple("Point", ["x", "y"])

    @dataclass
    class Container:
        points: list

    pts = [Point(1, 2), Point(3, 4), Point(5, 6)]
    c = Container(points=pts)
    codeflash_output = asdict(c); out = codeflash_output # 23.5μs -> 20.3μs (15.7% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import copy
from collections import namedtuple
from dataclasses import dataclass, field
from typing import Dict, List, Optional

# imports
import pytest
from src.datasets.utils.py_utils import asdict

# ========== BASIC TEST CASES ==========

def test_simple_dict_input():
    """Test that asdict returns an identical dict when passed a simple dict."""
    input_dict = {"key1": "value1", "key2": 42}
    codeflash_output = asdict(input_dict); result = codeflash_output # 12.9μs -> 10.3μs (25.8% faster)

def test_simple_dataclass_conversion():
    """Test conversion of a simple dataclass to dict."""
    @dataclass
    class SimpleClass:
        name: str
        age: int

    obj = SimpleClass(name="John", age=30)
    codeflash_output = asdict(obj); result = codeflash_output # 11.3μs -> 9.29μs (21.6% faster)

def test_nested_dataclass_conversion():
    """Test conversion of nested dataclasses to nested dicts."""
    @dataclass
    class Address:
        street: str
        city: str

    @dataclass
    class Person:
        name: str
        address: Address

    address = Address(street="123 Main St", city="Springfield")
    person = Person(name="Homer", address=address)
    codeflash_output = asdict(person); result = codeflash_output # 14.9μs -> 11.5μs (29.4% faster)
    expected = {"name": "Homer", "address": {"street": "123 Main St", "city": "Springfield"}}

def test_dict_with_list_values():
    """Test asdict with dict containing list values."""
    input_dict = {"items": [1, 2, 3], "tags": ["a", "b"]}
    codeflash_output = asdict(input_dict); result = codeflash_output # 19.7μs -> 15.4μs (27.8% faster)

def test_dataclass_with_list_field():
    """Test dataclass with list field."""
    @dataclass
    class Container:
        items: list
        name: str

    obj = Container(items=[1, 2, 3], name="test")
    codeflash_output = asdict(obj); result = codeflash_output # 16.3μs -> 13.1μs (24.3% faster)

def test_dataclass_with_tuple_field():
    """Test dataclass with tuple field."""
    @dataclass
    class Container:
        coordinates: tuple
        name: str

    obj = Container(coordinates=(1, 2, 3), name="point")
    codeflash_output = asdict(obj); result = codeflash_output # 16.0μs -> 13.0μs (23.4% faster)

def test_namedtuple_in_dataclass():
    """Test conversion of dataclass containing a namedtuple."""
    Point = namedtuple("Point", ["x", "y"])

    @dataclass
    class Location:
        name: str
        point: Point

    obj = Location(name="origin", point=Point(x=0, y=0))
    codeflash_output = asdict(obj); result = codeflash_output # 16.5μs -> 13.5μs (22.2% faster)

def test_dict_with_nested_dict_values():
    """Test dict containing nested dicts."""
    input_dict = {"outer": {"inner": {"value": 42}}}
    codeflash_output = asdict(input_dict); result = codeflash_output # 15.4μs -> 13.0μs (18.3% faster)

def test_dataclass_with_dict_field():
    """Test dataclass with dict field."""
    @dataclass
    class Config:
        settings: dict
        name: str

    obj = Config(settings={"debug": True, "timeout": 30}, name="prod")
    codeflash_output = asdict(obj); result = codeflash_output # 17.4μs -> 13.9μs (25.1% faster)

def test_primitive_types_in_dataclass():
    """Test dataclass with various primitive types."""
    @dataclass
    class Primitives:
        string_val: str
        int_val: int
        float_val: float
        bool_val: bool
        none_val: Optional[str]

    obj = Primitives(string_val="hello", int_val=42, float_val=3.14, bool_val=True, none_val=None)
    codeflash_output = asdict(obj); result = codeflash_output # 17.1μs -> 13.1μs (30.0% faster)

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

def test_empty_dict():
    """Test asdict with empty dict."""
    codeflash_output = asdict({}); result = codeflash_output # 5.32μs -> 5.62μs (5.36% slower)

def test_empty_dataclass():
    """Test asdict with empty dataclass."""
    @dataclass
    class Empty:
        pass

    obj = Empty()
    codeflash_output = asdict(obj); result = codeflash_output # 5.02μs -> 4.89μs (2.58% faster)

def test_dataclass_with_default_field_excluded():
    """Test that fields with default values are excluded if not initialized."""
    @dataclass
    class WithDefaults:
        name: str
        age: int = 0

    obj = WithDefaults(name="test")
    codeflash_output = asdict(obj); result = codeflash_output # 12.0μs -> 10.1μs (18.8% faster)

def test_dataclass_with_field_default_factory():
    """Test dataclass with field using default_factory."""
    @dataclass
    class WithFactory:
        name: str
        items: list = field(default_factory=list)

    obj = WithFactory(name="test")
    codeflash_output = asdict(obj); result = codeflash_output # 12.7μs -> 10.6μs (20.3% faster)

def test_dataclass_with_metadata_flag():
    """Test field with metadata flag include_in_asdict_even_if_is_default."""
    @dataclass
    class WithMetadata:
        name: str
        flag: bool = field(default=False, metadata={"include_in_asdict_even_if_is_default": True})

    obj = WithMetadata(name="test", flag=False)
    codeflash_output = asdict(obj); result = codeflash_output # 12.0μs -> 9.52μs (26.2% faster)

def test_dict_with_integer_keys():
    """Test dict with integer keys (preserved as dict)."""
    input_dict = {1: "one", 2: "two", 3: "three"}
    codeflash_output = asdict(input_dict); result = codeflash_output # 14.4μs -> 10.4μs (38.8% faster)

def test_dict_with_tuple_keys():
    """Test dict with tuple keys."""
    input_dict = {(1, 2): "value1", (3, 4): "value2"}
    codeflash_output = asdict(input_dict); result = codeflash_output # 18.7μs -> 15.2μs (23.2% faster)

def test_deeply_nested_lists():
    """Test with deeply nested lists."""
    @dataclass
    class Nested:
        data: list

    obj = Nested(data=[[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
    codeflash_output = asdict(obj); result = codeflash_output # 26.3μs -> 22.8μs (15.3% faster)

def test_mixed_list_and_dict():
    """Test list containing both dicts and primitives."""
    input_dict = {"items": [{"id": 1}, {"id": 2}, "text"]}
    codeflash_output = asdict(input_dict); result = codeflash_output # 20.0μs -> 16.3μs (22.9% faster)

def test_namedtuple_standalone_in_dict():
    """Test dict value that is a namedtuple."""
    Point = namedtuple("Point", ["x", "y"])
    input_dict = {"location": Point(x=10, y=20)}
    codeflash_output = asdict(input_dict); result = codeflash_output # 14.4μs -> 12.2μs (17.6% faster)

def test_namedtuple_with_nested_data():
    """Test namedtuple containing nested structures."""
    Point = namedtuple("Point", ["x", "y"])

    @dataclass
    class LocationData:
        points: list

    obj = LocationData(points=[Point(x=0, y=0), Point(x=1, y=1)])
    codeflash_output = asdict(obj); result = codeflash_output # 20.2μs -> 16.6μs (21.7% faster)

def test_empty_list_in_dataclass():
    """Test dataclass with empty list."""
    @dataclass
    class Container:
        items: list
        name: str

    obj = Container(items=[], name="empty")
    codeflash_output = asdict(obj); result = codeflash_output # 12.1μs -> 10.7μs (13.6% faster)

def test_empty_dict_in_dataclass():
    """Test dataclass with empty dict field."""
    @dataclass
    class Config:
        settings: dict
        name: str

    obj = Config(settings={}, name="empty")
    codeflash_output = asdict(obj); result = codeflash_output # 11.4μs -> 10.5μs (8.07% faster)

def test_special_float_values():
    """Test with special float values."""
    @dataclass
    class Numbers:
        value1: float
        value2: float

    obj = Numbers(value1=float('inf'), value2=float('-inf'))
    codeflash_output = asdict(obj); result = codeflash_output # 11.4μs -> 9.34μs (22.4% faster)

def test_special_nan_value():
    """Test with NaN value."""
    @dataclass
    class Numbers:
        value: float

    obj = Numbers(value=float('nan'))
    codeflash_output = asdict(obj); result = codeflash_output # 9.48μs -> 7.71μs (23.0% faster)

def test_mixed_dataclass_and_dict_nesting():
    """Test mixed nesting of dataclass and dict."""
    @dataclass
    class Inner:
        value: int

    outer_dict = {"inner": Inner(value=42), "other": "data"}
    codeflash_output = asdict(outer_dict); result = codeflash_output # 15.3μs -> 12.1μs (25.8% faster)

def test_tuple_containing_dataclass():
    """Test tuple containing a dataclass instance."""
    @dataclass
    class Item:
        name: str
        value: int

    @dataclass
    class Collection:
        items: tuple

    item1 = Item(name="first", value=1)
    item2 = Item(name="second", value=2)
    obj = Collection(items=(item1, item2))
    codeflash_output = asdict(obj); result = codeflash_output # 19.6μs -> 17.0μs (15.1% faster)

def test_dataclass_non_init_field():
    """Test dataclass with non-init field."""
    @dataclass
    class WithNonInit:
        name: str
        computed: int = field(init=False, default=0)

    obj = WithNonInit(name="test")
    codeflash_output = asdict(obj); result = codeflash_output # 11.5μs -> 9.25μs (24.2% faster)

def test_invalid_input_not_dict_or_dataclass():
    """Test that TypeError is raised for invalid input type."""
    with pytest.raises(TypeError):
        asdict([1, 2, 3]) # 7.20μs -> 7.07μs (1.84% faster)

def test_invalid_input_class_not_instance():
    """Test that TypeError is raised for dataclass class (not instance)."""
    @dataclass
    class MyClass:
        value: int

    with pytest.raises(TypeError):
        asdict(MyClass) # 5.12μs -> 4.98μs (2.69% faster)

def test_invalid_input_string():
    """Test that TypeError is raised for string input."""
    with pytest.raises(TypeError):
        asdict("not a dict or dataclass") # 4.46μs -> 4.11μs (8.56% faster)

def test_invalid_input_integer():
    """Test that TypeError is raised for integer input."""
    with pytest.raises(TypeError):
        asdict(42) # 4.52μs -> 4.51μs (0.089% faster)

def test_invalid_input_none():
    """Test that TypeError is raised for None input."""
    with pytest.raises(TypeError):
        asdict(None) # 4.63μs -> 4.24μs (9.32% faster)

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

def test_large_dict_many_keys():
    """Test asdict performance with dict containing many keys."""
    large_dict = {f"key_{i}": f"value_{i}" for i in range(500)}
    codeflash_output = asdict(large_dict); result = codeflash_output # 1.03ms -> 569μs (81.3% faster)

def test_large_dataclass_many_fields():
    """Test dataclass with many fields."""
    # Create a dataclass with many fields dynamically
    fields_dict = {f"field_{i}": (int, field(default=i)) for i in range(100)}
    LargeClass = dataclass(type("LargeClass", (), fields_dict))
    
    obj = LargeClass()
    codeflash_output = asdict(obj); result = codeflash_output # 5.17μs -> 5.16μs (0.194% faster)

def test_large_nested_list():
    """Test dataclass with large list."""
    @dataclass
    class ListContainer:
        items: list

    obj = ListContainer(items=list(range(500)))
    codeflash_output = asdict(obj); result = codeflash_output # 523μs -> 304μs (71.9% faster)

def test_large_nested_dict_structure():
    """Test deeply nested dict structure."""
    nested = {}
    current = nested
    for i in range(50):
        current[f"level_{i}"] = {}
        current = current[f"level_{i}"]
    current["final_value"] = 42

    codeflash_output = asdict(nested); result = codeflash_output # 131μs -> 117μs (11.4% faster)
    # Navigate to final value
    current_result = result
    for i in range(50):
        current_result = current_result[f"level_{i}"]

def test_large_list_of_dicts():
    """Test list containing many dicts."""
    input_dict = {"items": [{"id": i, "name": f"item_{i}"} for i in range(300)]}
    codeflash_output = asdict(input_dict); result = codeflash_output # 1.55ms -> 1.05ms (47.7% faster)

def test_large_list_of_dataclasses():
    """Test list of many dataclass instances."""
    @dataclass
    class Item:
        id: int
        name: str

    @dataclass
    class Container:
        items: list

    items = [Item(id=i, name=f"item_{i}") for i in range(200)]
    obj = Container(items=items)
    codeflash_output = asdict(obj); result = codeflash_output # 691μs -> 488μs (41.6% faster)

def test_large_dict_with_list_values():
    """Test dict where many values are lists."""
    input_dict = {f"list_{i}": list(range(10)) for i in range(100)}
    codeflash_output = asdict(input_dict); result = codeflash_output # 1.23ms -> 776μs (58.6% faster)

def test_dict_independent_copy():
    """Test that modifying result doesn't affect original."""
    original = {"items": [1, 2, 3], "nested": {"value": 42}}
    codeflash_output = asdict(original); result = codeflash_output # 19.3μs -> 14.8μs (30.5% faster)
    
    # Modify the result
    result["items"].append(4)
    result["nested"]["value"] = 100

def test_dataclass_independent_copy():
    """Test that modifying result doesn't affect original dataclass."""
    @dataclass
    class Data:
        items: list
        value: int

    original = Data(items=[1, 2, 3], value=42)
    codeflash_output = asdict(original); result = codeflash_output # 15.5μs -> 12.7μs (21.6% faster)
    
    # Modify the result
    result["items"].append(4)
    result["value"] = 100

def test_complex_namedtuple_structure():
    """Test complex structure with multiple namedtuples."""
    Point = namedtuple("Point", ["x", "y"])
    Color = namedtuple("Color", ["r", "g", "b"])

    @dataclass
    class Shape:
        points: list
        color: Color

    points = [Point(x=i, y=i*2) for i in range(50)]
    color = Color(r=255, g=128, b=0)
    obj = Shape(points=points, color=color)
    
    codeflash_output = asdict(obj); result = codeflash_output # 174μs -> 135μs (28.3% faster)

def test_multiple_namedtuples_in_dict():
    """Test dict with multiple different namedtuples as values."""
    Point = namedtuple("Point", ["x", "y"])
    Size = namedtuple("Size", ["width", "height"])
    
    input_dict = {
        "points": [Point(x=i, y=i) for i in range(50)],
        "sizes": [Size(width=i*10, height=i*20) for i in range(50)]
    }
    
    codeflash_output = asdict(input_dict); result = codeflash_output # 326μs -> 256μs (27.6% faster)

def test_dict_with_unicode_keys_and_values():
    """Test dict with unicode characters."""
    input_dict = {
        "name": "John",
        "greeting": "Hello, World!",
        "emoji": "smile",
        "symbols": "!@#$%^&*()"
    }
    codeflash_output = asdict(input_dict); result = codeflash_output # 16.5μs -> 11.4μs (45.5% faster)

def test_dataclass_with_unicode_data():
    """Test dataclass containing unicode strings."""
    @dataclass
    class Text:
        content: str
        language: str

    obj = Text(content="Bonjour le monde", language="fr")
    codeflash_output = asdict(obj); result = codeflash_output # 11.5μs -> 8.89μs (29.8% 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-asdict-mlchvwu3 and push.