⚡️ Speed up function accumulate_delta by 14%

[codeflash-ai]

📄 14% (0.14x) speedup for accumulate_delta in src/openai/lib/streaming/_assistants.py

⏱️ Runtime : 985 microseconds → 867 microseconds (best of 162 runs)

📝 Explanation and details

The optimization achieves a 13% speedup through three key changes:

1. Eliminated Function Call Overhead:
Replaced custom is_dict() and is_list() wrapper functions with direct isinstance() calls. The line profiler shows is_dict() was called 1,809 times, consuming 358µs. Direct isinstance() calls eliminate this overhead since Python's C-implemented isinstance() is highly optimized.

2. Optimized Set Membership Check:
Changed if key == "index" or key == "type": to if key in {"index", "type"}:. Set membership testing is faster than chained equality comparisons, especially when called frequently (4,109 times according to the profiler).

3. Improved List Type Checking:
Replaced all(isinstance(x, (str, int, float)) for x in acc_value) with an explicit loop that breaks early. This avoids potential generator overhead and provides better control flow for the type checking logic.

Performance Impact by Test Case:

• List operations see the biggest gains (24-66% faster): The elimination of function call overhead in list processing provides substantial benefits for cases like test_accumulate_simple_list_of_scalars and test_accumulate_lists_of_primitives.
• Nested dictionary operations show 16-39% improvements due to reduced overhead in recursive calls.
• Simple scalar operations see modest 3-7% gains from the set membership optimization.
• Large-scale tests demonstrate consistent 2-27% improvements, showing the optimizations scale well.

These optimizations are particularly effective for workloads with frequent list processing and nested dictionary operations, which are common in streaming data accumulation scenarios.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from openai.lib.streaming._assistants import accumulate_delta
# function to test
from typing_extensions import TypeGuard

# unit tests

# --------------------------
# 1. BASIC TEST CASES
# --------------------------

def test_accumulate_new_key():
    # Adding a new key to an empty dict
    acc = {}
    delta = {'a': 1}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 937ns -> 998ns (6.11% slower)

def test_accumulate_existing_int():
    # Accumulating ints
    acc = {'a': 1}
    delta = {'a': 2}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 1.61μs -> 1.50μs (7.49% faster)

def test_accumulate_existing_float():
    # Accumulating floats
    acc = {'a': 1.5}
    delta = {'a': 2.5}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 1.40μs -> 1.36μs (3.24% faster)

def test_accumulate_existing_str():
    # Accumulating strings (concatenation)
    acc = {'a': 'foo'}
    delta = {'a': 'bar'}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 1.23μs -> 1.16μs (6.23% faster)

def test_accumulate_none_value():
    # If acc value is None, it should be replaced by delta value
    acc = {'a': None}
    delta = {'a': 5}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 777ns -> 777ns (0.000% faster)

def test_accumulate_nested_dict():
    # Nested dicts should be accumulated recursively
    acc = {'a': {'b': 1}}
    delta = {'a': {'b': 2, 'c': 3}}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 2.61μs -> 2.20μs (19.0% faster)

def test_accumulate_simple_list_of_scalars():
    # Simple lists of scalars should be extended
    acc = {'a': [1, 2]}
    delta = {'a': [3, 4]}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 3.17μs -> 1.95μs (62.5% faster)

def test_accumulate_new_list_key():
    # New list key added
    acc = {}
    delta = {'a': [1, 2]}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 797ns -> 779ns (2.31% faster)

def test_accumulate_type_and_index_keys():
    # "type" and "index" keys should be replaced, not accumulated
    acc = {'type': 'foo', 'index': 1}
    delta = {'type': 'bar', 'index': 2}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 1.15μs -> 1.07μs (7.10% faster)

# --------------------------
# 2. EDGE TEST CASES
# --------------------------

def test_accumulate_empty_delta():
    # Delta is empty, acc should remain unchanged
    acc = {'a': 1}
    delta = {}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 585ns -> 594ns (1.52% slower)

def test_accumulate_empty_acc():
    # Acc is empty, delta should be copied in
    acc = {}
    delta = {'a': 1}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 783ns -> 753ns (3.98% faster)

def test_accumulate_empty_both():
    # Both acc and delta are empty
    acc = {}
    delta = {}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 592ns -> 569ns (4.04% faster)

def test_accumulate_list_of_dicts_insert():
    # Insert a new dict into a list of dicts at a new index
    acc = {'a': [{'foo': 'bar', 'index': 0}]}
    delta = {'a': [{'foo': 'baz', 'index': 1}]}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 4.23μs -> 2.65μs (59.2% faster)

def test_accumulate_list_of_dicts_update():
    # Update a dict in a list of dicts at an existing index
    acc = {'a': [{'foo': 'bar', 'index': 0}, {'foo': 'baz', 'index': 1}]}
    delta = {'a': [{'foo': 'qux', 'index': 1}]}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 4.20μs -> 3.05μs (37.7% faster)

def test_accumulate_list_of_dicts_missing_index_key():
    # Should raise RuntimeError if delta entry in list of dicts lacks "index"
    acc = {'a': [{'foo': 'bar', 'index': 0}]}
    delta = {'a': [{'foo': 'baz'}]}
    with pytest.raises(RuntimeError):
        accumulate_delta(acc, delta) # 5.55μs -> 4.42μs (25.5% faster)

def test_accumulate_list_of_dicts_non_int_index():
    # Should raise TypeError if "index" is not int
    acc = {'a': [{'foo': 'bar', 'index': 0}]}
    delta = {'a': [{'foo': 'baz', 'index': 'one'}]}
    with pytest.raises(TypeError):
        accumulate_delta(acc, delta) # 3.39μs -> 2.42μs (39.8% faster)

def test_accumulate_list_of_dicts_non_dict_entry():
    # Should raise TypeError if delta entry in list is not a dict
    acc = {'a': [{'foo': 'bar', 'index': 0}]}
    delta = {'a': ['notadict']}
    with pytest.raises(TypeError):
        accumulate_delta(acc, delta) # 3.22μs -> 2.22μs (45.1% faster)


def test_accumulate_list_with_gap_in_index():
    # Insert at index beyond current length, should insert at index
    acc = {'a': [{'foo': 'bar', 'index': 0}]}
    delta = {'a': [{'foo': 'baz', 'index': 2}]}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 4.53μs -> 2.93μs (54.9% faster)

def test_accumulate_with_float_and_int():
    # Mixing int and float should sum correctly
    acc = {'a': 1}
    delta = {'a': 2.5}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 1.69μs -> 1.64μs (3.18% faster)

def test_accumulate_with_str_and_non_str():
    # If types don't match, should replace
    acc = {'a': 'foo'}
    delta = {'a': 123}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 1.87μs -> 1.43μs (30.6% faster)

def test_accumulate_with_dict_and_non_dict():
    # If types don't match, should replace
    acc = {'a': {'b': 1}}
    delta = {'a': 2}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 1.75μs -> 1.38μs (27.0% faster)

def test_accumulate_with_list_and_non_list():
    # If types don't match, should replace
    acc = {'a': [1, 2]}
    delta = {'a': 'foo'}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 1.66μs -> 1.29μs (28.4% faster)

def test_accumulate_with_none_delta():
    # If delta value is None, should replace acc value
    acc = {'a': 1}
    delta = {'a': None}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 1.72μs -> 1.44μs (20.1% faster)

def test_accumulate_with_nested_type_index():
    # "index" and "type" keys in nested dicts should be replaced, not accumulated
    acc = {'a': {'type': 'foo', 'index': 1}}
    delta = {'a': {'type': 'bar', 'index': 2}}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 2.15μs -> 1.85μs (16.4% faster)

# --------------------------
# 3. LARGE SCALE TEST CASES
# --------------------------

def test_accumulate_large_flat_dict():
    # Large flat dict of ints
    acc = {str(i): i for i in range(500)}
    delta = {str(i): i for i in range(500)}
    expected = {str(i): i*2 for i in range(500)}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 86.0μs -> 83.5μs (2.97% faster)

def test_accumulate_large_nested_dict():
    # Large nested dict
    acc = {'outer': {str(i): i for i in range(100)}}
    delta = {'outer': {str(i): i for i in range(100)}}
    expected = {'outer': {str(i): i*2 for i in range(100)}}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 19.5μs -> 18.3μs (6.49% faster)

def test_accumulate_large_list_of_scalars():
    # Large list of scalars
    acc = {'a': list(range(500))}
    delta = {'a': list(range(500, 1000))}
    expected = {'a': list(range(1000))}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 28.0μs -> 22.4μs (24.7% faster)

def test_accumulate_large_list_of_dicts():
    # Large list of dicts with index
    acc = {'a': [{'val': i, 'index': i} for i in range(10)]}
    delta = {'a': [{'val': 100 + i, 'index': i} for i in range(10)]}
    # Each dict at index i should have its 'val' accumulated
    expected = {'a': [{'val': i + 100 + i, 'index': i} for i in range(10)]}
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 9.16μs -> 6.98μs (31.3% faster)

def test_accumulate_large_mixed():
    # Large dict with mixed types and nested structures
    acc = {
        'ints': {str(i): i for i in range(100)},
        'floats': {str(i): float(i) for i in range(100)},
        'strings': {str(i): str(i) for i in range(100)},
        'lists': [i for i in range(100)],
        'dicts': [{'val': i, 'index': i} for i in range(10)]
    }
    delta = {
        'ints': {str(i): i for i in range(100)},
        'floats': {str(i): float(i) for i in range(100)},
        'strings': {str(i): str(i) for i in range(100, 200)},
        'lists': [i for i in range(100, 200)],
        'dicts': [{'val': 100 + i, 'index': i} for i in range(10)]
    }
    expected = {
        'ints': {str(i): i*2 for i in range(100)},
        'floats': {str(i): float(i)*2 for i in range(100)},
        'strings': {str(i): str(i) for i in range(100)} | {str(i): str(i) for i in range(100, 200)},
        'lists': [i for i in range(200)],
        'dicts': [{'val': i + 100 + i, 'index': i} for i in range(10)]
    }
    codeflash_output = accumulate_delta(acc, delta); result = codeflash_output # 58.5μs -> 53.1μs (10.1% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from copy import deepcopy

# imports
import pytest  # used for our unit tests
from openai.lib.streaming._assistants import accumulate_delta
# function to test
from typing_extensions import TypeGuard

# unit tests

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

def test_accumulate_simple_strings():
    # Accumulate two string values
    acc = {'a': 'foo'}
    delta = {'a': 'bar'}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 1.11μs -> 1.14μs (2.73% slower)

def test_accumulate_simple_ints():
    # Accumulate two integer values
    acc = {'x': 1}
    delta = {'x': 2}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 1.38μs -> 1.29μs (6.72% faster)

def test_accumulate_simple_floats():
    # Accumulate two float values
    acc = {'y': 1.5}
    delta = {'y': 2.5}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 1.28μs -> 1.19μs (7.49% faster)

def test_accumulate_new_key():
    # Delta introduces a new key
    acc = {'a': 1}
    delta = {'b': 2}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 622ns -> 591ns (5.25% faster)

def test_accumulate_none_value():
    # acc value is None, should be replaced by delta value
    acc = {'a': None}
    delta = {'a': 'foo'}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 728ns -> 694ns (4.90% faster)

def test_accumulate_index_and_type_keys():
    # index and type keys should be replaced, not accumulated
    acc = {'index': 0, 'type': 'old'}
    delta = {'index': 1, 'type': 'new'}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 970ns -> 960ns (1.04% faster)

def test_accumulate_dicts():
    # Nested dictionaries should be accumulated recursively
    acc = {'d': {'x': 1}}
    delta = {'d': {'x': 2, 'y': 3}}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 2.48μs -> 1.99μs (24.5% faster)

def test_accumulate_lists_of_primitives():
    # Lists of primitives should be extended
    acc = {'lst': [1, 2]}
    delta = {'lst': [3, 4]}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 3.10μs -> 1.87μs (65.6% faster)

def test_accumulate_lists_of_strings():
    acc = {'lst': ['a', 'b']}
    delta = {'lst': ['c', 'd']}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 2.39μs -> 1.61μs (48.6% faster)

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

def test_accumulate_empty_acc_and_delta():
    # Both acc and delta are empty
    acc = {}
    delta = {}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 455ns -> 427ns (6.56% faster)

def test_accumulate_empty_delta():
    # Delta is empty, acc should remain unchanged
    acc = {'a': 1, 'b': 2}
    delta = {}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 475ns -> 461ns (3.04% faster)

def test_accumulate_empty_acc():
    # Acc is empty, should copy delta
    acc = {}
    delta = {'a': 1, 'b': 2}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 820ns -> 753ns (8.90% faster)

def test_accumulate_list_of_dicts_insert():
    # List of dicts, delta with new index
    acc = {'lst': [{'foo': 'bar', 'index': 0}]}
    delta = {'lst': [{'foo': 'baz', 'index': 1}]}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 4.06μs -> 2.59μs (56.7% faster)

def test_accumulate_list_of_dicts_update():
    # List of dicts, delta updates existing index
    acc = {'lst': [{'foo': 'bar', 'index': 0}]}
    delta = {'lst': [{'foo': 'baz', 'index': 0}]}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 3.86μs -> 2.76μs (39.5% faster)

def test_accumulate_list_of_dicts_missing_index_key():
    # Delta entry missing 'index' key should raise RuntimeError
    acc = {'lst': [{'foo': 'bar', 'index': 0}]}
    delta = {'lst': [{'foo': 'baz'}]}
    with pytest.raises(RuntimeError):
        accumulate_delta(deepcopy(acc), deepcopy(delta)) # 5.34μs -> 4.18μs (27.6% faster)

def test_accumulate_list_of_dicts_non_int_index():
    # Delta entry with non-int index should raise TypeError
    acc = {'lst': [{'foo': 'bar', 'index': 0}]}
    delta = {'lst': [{'foo': 'baz', 'index': 'not-an-int'}]}
    with pytest.raises(TypeError):
        accumulate_delta(deepcopy(acc), deepcopy(delta)) # 3.42μs -> 2.30μs (48.8% faster)

def test_accumulate_list_of_dicts_non_dict_entry():
    # Delta entry not a dict should raise TypeError
    acc = {'lst': [{'foo': 'bar', 'index': 0}]}
    delta = {'lst': ['not-a-dict']}
    with pytest.raises(TypeError):
        accumulate_delta(deepcopy(acc), deepcopy(delta)) # 3.14μs -> 2.10μs (49.2% faster)


def test_accumulate_list_of_dicts_index_out_of_range():
    # Delta entry index out of range should insert
    acc = {'lst': [{'foo': 'bar', 'index': 0}]}
    delta = {'lst': [{'foo': 'baz', 'index': 1}]}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 4.22μs -> 2.70μs (56.5% faster)

def test_accumulate_mixed_types():
    # acc and delta have mixed types
    acc = {'a': 1, 'b': 'foo', 'c': [1, 2], 'd': {'x': 1}}
    delta = {'a': 2, 'b': 'bar', 'c': [3], 'd': {'x': 2, 'y': 3}}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 4.73μs -> 3.53μs (34.1% faster)

def test_accumulate_nested_dicts_and_lists():
    # Deeply nested dicts and lists
    acc = {'outer': {'inner': {'val': 'a', 'lst': [1]}}}
    delta = {'outer': {'inner': {'val': 'b', 'lst': [2, 3]}}}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 4.12μs -> 2.99μs (38.0% faster)

def test_accumulate_delta_does_not_mutate_inputs():
    # Ensure inputs are not mutated
    acc = {'a': 1}
    delta = {'a': 2}
    acc_copy = deepcopy(acc)
    delta_copy = deepcopy(delta)
    accumulate_delta(acc, delta) # 1.28μs -> 1.20μs (6.91% faster)

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

def test_large_flat_dict():
    # Large flat dict of ints
    acc = {i: i for i in range(1000)}
    delta = {i: 1 for i in range(1000)}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 163μs -> 157μs (3.85% faster)

def test_large_flat_dict_strings():
    # Large flat dict of strings
    acc = {str(i): 'a' for i in range(1000)}
    delta = {str(i): 'b' for i in range(1000)}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 129μs -> 126μs (2.01% faster)

def test_large_list_of_ints():
    # Large list of ints
    acc = {'lst': list(range(500))}
    delta = {'lst': list(range(500, 1000))}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 28.4μs -> 22.4μs (27.0% faster)

def test_large_list_of_dicts_insert_and_update():
    # Large list of dicts with updates and inserts
    acc = {'lst': [{'val': i, 'index': i} for i in range(500)]}
    delta = {'lst': [{'val': 1000+i, 'index': 500+i} for i in range(500)] + 
                   [{'val': 2000+i, 'index': i} for i in range(500)]}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 305μs -> 251μs (21.4% faster)
    # Check inserts
    for i in range(500, 1000):
        pass
    # Check updates
    for i in range(500):
        pass

def test_large_nested_dicts():
    # Large nested dicts
    acc = {'outer': {str(i): {'val': i} for i in range(100)}}
    delta = {'outer': {str(i): {'val': 1} for i in range(100)}}
    codeflash_output = accumulate_delta(deepcopy(acc), deepcopy(delta)); result = codeflash_output # 50.4μs -> 42.3μs (19.2% faster)
    for i in range(100):
        pass


#------------------------------------------------
from openai.lib.streaming._assistants import accumulate_delta

def test_accumulate_delta():
    accumulate_delta({'\x00\x00\x00\x00\x00': float('nan')}, {'\x00\x00\x00\x00\x00': float('nan'), '\x01\x02\x00\x02\x00': '', '\x00\x01\x00\x00\x00': 0})

def test_accumulate_delta_2():
    accumulate_delta({2: ''}, {2: 0})

def test_accumulate_delta_3():
    accumulate_delta({4: ''}, {3: '', 4: ''})

def test_accumulate_delta_4():
    accumulate_delta({'index': 0}, {'index': 0})

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_g6lys7gg/tmpytw0lpzt/test_concolic_coverage.py::test_accumulate_delta	1.64μs	1.50μs	9.41%✅
codeflash_concolic_g6lys7gg/tmpytw0lpzt/test_concolic_coverage.py::test_accumulate_delta_2	2.04μs	1.48μs	38.6%✅
codeflash_concolic_g6lys7gg/tmpytw0lpzt/test_concolic_coverage.py::test_accumulate_delta_3	1.47μs	1.37μs	7.29%✅
codeflash_concolic_g6lys7gg/tmpytw0lpzt/test_concolic_coverage.py::test_accumulate_delta_4	843ns	855ns	-1.40%⚠️

To edit these changes git checkout codeflash/optimize-accumulate_delta-mhd7bdjv and push.