⚡️ Speed up function deep_union_pydantic_dicts by 19%

[codeflash-ai]

📄 19% (0.19x) speedup for deep_union_pydantic_dicts in skyvern/client/core/pydantic_utilities.py

⏱️ Runtime : 574 microseconds → 481 microseconds (best of 196 runs)

📝 Explanation and details

The optimization achieves a 19% speedup through two key Python performance improvements:

1. Type Checking Optimization
Replaced isinstance(item, dict) and isinstance(value, dict) with type(item) is dict and type(value) is dict. This is significantly faster because:

• isinstance() performs inheritance chain lookups to handle subclasses
• type() is does direct type comparison without subclass checking
• Since this code processes Pydantic model dictionaries (not custom dict subclasses), the direct type check is safe and much faster

2. Attribute Lookup Reduction
In deep_union_pydantic_dicts, cached frequently-used attributes as local variables:

• src_items = source.items() - avoids repeated method lookup
• dest = destination and setdefault = dest.setdefault - eliminates attribute lookups in the hot loop

Performance Impact Analysis:
The optimizations are most effective for large, flat dictionaries where the function shows 60-74% speedups in test cases. For nested structures, improvements are more modest (5-25%) but still consistent. The function is called from Pydantic model serialization (dict() method) in a hot path, making these micro-optimizations valuable for applications processing many Pydantic models.

Test Case Performance:

• Large flat dicts: 60.8-74.1% faster (most benefit from reduced type checking overhead)
• Nested structures: 5-25% faster (benefit from both optimizations)
• Small structures: 10-25% faster (type checking still helps)

The optimizations maintain identical behavior while providing meaningful performance gains, especially important given this function's role in Pydantic model serialization workflows.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Any, Dict, List

# imports
import pytest  # used for our unit tests
from skyvern.client.core.pydantic_utilities import deep_union_pydantic_dicts

# unit tests

# 1. Basic Test Cases

def test_basic_flat_dict_union():
    # Test merging two flat dictionaries
    src = {"a": 1, "b": 2}
    dst = {"b": 3, "c": 4}
    codeflash_output = deep_union_pydantic_dicts(src, dst.copy()); result = codeflash_output # 1.35μs -> 1.12μs (20.1% faster)

def test_basic_nested_dict_union():
    # Test merging nested dictionaries
    src = {"a": {"x": 1}, "b": 2}
    dst = {"a": {"y": 2}, "b": 3, "c": 4}
    codeflash_output = deep_union_pydantic_dicts(src, dst.copy()); result = codeflash_output # 1.76μs -> 1.68μs (5.25% faster)

def test_basic_list_in_dict_union():
    # Test merging dictionaries with lists
    src = {"a": [1, 2], "b": 2}
    dst = {"a": [3, 4], "b": 3, "c": 4}
    codeflash_output = deep_union_pydantic_dicts(src, dst.copy()); result = codeflash_output # 2.33μs -> 2.10μs (10.9% faster)

def test_basic_list_of_dicts_union():
    # Test merging lists of dicts inside dicts
    src = {"a": [{"x": 1}, {"y": 2}]}
    dst = {"a": [{"x": 3}, {"z": 4}]}
    codeflash_output = deep_union_pydantic_dicts(src, dst.copy()); result = codeflash_output # 2.61μs -> 2.58μs (0.928% faster)

# 2. Edge Test Cases

def test_empty_source_dict():
    # Source is empty, destination should remain unchanged
    src = {}
    dst = {"a": 1, "b": 2}
    codeflash_output = deep_union_pydantic_dicts(src, dst.copy()); result = codeflash_output # 435ns -> 568ns (23.4% slower)

def test_empty_destination_dict():
    # Destination is empty, source should be copied over
    src = {"a": 1, "b": 2}
    dst = {}
    codeflash_output = deep_union_pydantic_dicts(src, dst.copy()); result = codeflash_output # 1.26μs -> 1.01μs (25.2% faster)

def test_both_empty_dicts():
    # Both are empty, result should be empty
    src = {}
    dst = {}
    codeflash_output = deep_union_pydantic_dicts(src, dst.copy()); result = codeflash_output # 470ns -> 549ns (14.4% slower)

def test_deeply_nested_dicts():
    # Deeply nested dictionaries
    src = {"a": {"b": {"c": {"d": 1}}}}
    dst = {"a": {"b": {"c": {"e": 2}}}}
    codeflash_output = deep_union_pydantic_dicts(src, dst.copy()); result = codeflash_output # 1.73μs -> 1.91μs (9.18% slower)

def test_list_of_lists():
    # Lists of lists inside dicts
    src = {"a": [[1, 2], [3, 4]]}
    dst = {"a": [[5, 6], [7, 8]]}
    codeflash_output = deep_union_pydantic_dicts(src, dst.copy()); result = codeflash_output # 2.86μs -> 2.71μs (5.69% faster)

def test_list_mismatched_lengths():
    # Lists of different lengths should raise IndexError
    src = {"a": [1, 2, 3]}
    dst = {"a": [4, 5]}
    with pytest.raises(IndexError):
        deep_union_pydantic_dicts(src, dst.copy()) # 2.35μs -> 2.18μs (7.88% faster)

def test_dict_with_none_values():
    # None values should overwrite destination values
    src = {"a": None}
    dst = {"a": 1}
    codeflash_output = deep_union_pydantic_dicts(src, dst.copy()); result = codeflash_output # 866ns -> 852ns (1.64% faster)

def test_dict_with_bool_and_zero():
    # Test with False and 0 values
    src = {"a": False, "b": 0}
    dst = {"a": True, "b": 1}
    codeflash_output = deep_union_pydantic_dicts(src, dst.copy()); result = codeflash_output # 1.25μs -> 1.03μs (21.4% faster)

def test_dict_with_empty_list_and_dict():
    # Test with empty list and dict values
    src = {"a": [], "b": {}}
    dst = {"a": [1], "b": {"x": 1}}
    codeflash_output = deep_union_pydantic_dicts(src, dst.copy()); result = codeflash_output # 2.02μs -> 2.09μs (3.45% slower)

def test_large_flat_dict_union():
    # Merge two large flat dictionaries
    src = {str(i): i for i in range(500)}
    dst = {str(i): -i for i in range(500, 1000)}
    codeflash_output = deep_union_pydantic_dicts(src, dst.copy()); result = codeflash_output # 48.7μs -> 30.3μs (60.8% faster)
    # Should contain all keys from 0 to 999, with correct values
    for i in range(500):
        pass
    for i in range(500, 1000):
        pass

def test_large_nested_dict_union():
    # Merge two large nested dictionaries
    src = {str(i): {"x": i} for i in range(500)}
    dst = {str(i): {"y": -i} for i in range(500, 1000)}
    codeflash_output = deep_union_pydantic_dicts(src, dst.copy()); result = codeflash_output # 113μs -> 102μs (11.1% faster)
    # Keys 0-499 should have both 'x' and 'y', keys 500-999 only 'y'
    for i in range(500):
        pass
    for i in range(500, 1000):
        pass

def test_large_list_of_dicts_union():
    # Merge large lists of dicts inside a dict
    src = {"a": [{"x": i} for i in range(100)]}
    dst = {"a": [{"y": -i} for i in range(100)]}
    codeflash_output = deep_union_pydantic_dicts(src, dst.copy()); result = codeflash_output # 20.9μs -> 18.0μs (16.7% faster)
    # Each dict in the list should have both 'x' and 'y'
    for i in range(100):
        pass

def test_large_deeply_nested_structure():
    # Merge large deeply nested structures
    src = {"root": {"level1": {"level2": {"level3": {str(i): i for i in range(100)}}}}}
    dst = {"root": {"level1": {"level2": {"level3": {str(i): -i for i in range(100, 200)}}}}}
    codeflash_output = deep_union_pydantic_dicts(src, dst.copy()); result = codeflash_output # 12.0μs -> 7.96μs (51.5% faster)
    # Should contain all keys from 0 to 199, with correct values
    merged = result["root"]["level1"]["level2"]["level3"]
    for i in range(100):
        pass
    for i in range(100, 200):
        pass

def test_large_list_of_lists():
    # Merge large lists of lists inside dicts
    src = {"a": [[i, i+1] for i in range(50)]}
    dst = {"a": [[-i, -(i+1)] for i in range(50)]}
    codeflash_output = deep_union_pydantic_dicts(src, dst.copy()); result = codeflash_output # 14.4μs -> 12.0μs (20.0% faster)
    for i in range(50):
        pass

# Additional mutation-sensitive test: destination is mutated in-place
def test_inplace_mutation():
    src = {"a": 1}
    dst = {"b": 2}
    codeflash_output = deep_union_pydantic_dicts(src, dst); result = codeflash_output # 931ns -> 806ns (15.5% faster)

# Additional test: source dict is not mutated
def test_source_not_mutated():
    src = {"a": {"b": 1}}
    dst = {"a": {"c": 2}}
    src_copy = src.copy()
    deep_union_pydantic_dicts(src, dst.copy()) # 1.32μs -> 1.35μs (2.07% slower)

# Additional test: merging with non-dict destination value

import copy
from typing import Any, Dict, List

# function to test (from skyvern/client/core/pydantic_utilities.py)
import pydantic
# imports
import pytest
from skyvern.client.core.pydantic_utilities import deep_union_pydantic_dicts

# unit tests

# 1. Basic Test Cases

def test_basic_flat_dict_union():
    # Simple flat dicts, source overwrites destination for overlapping keys
    src = {"a": 1, "b": 2}
    dst = {"b": 3, "c": 4}
    expected = {"a": 1, "b": 2, "c": 4}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 1.26μs -> 1.15μs (9.87% faster)

def test_basic_nested_dict_union():
    # Nested dicts, source values should deep-merge into destination
    src = {"a": {"x": 1}, "b": 2}
    dst = {"a": {"y": 2}, "b": 3}
    expected = {"a": {"x": 1, "y": 2}, "b": 2}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 1.54μs -> 1.55μs (0.647% slower)

def test_basic_list_in_dict_union():
    # Lists are merged element-wise
    src = {"a": [1, 2, 3]}
    dst = {"a": [4, 5, 6]}
    expected = {"a": [1, 2, 3]}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 2.18μs -> 2.01μs (8.42% faster)

def test_basic_list_of_dicts_union():
    # Lists of dicts are merged element-wise
    src = {"a": [{"x": 1}, {"y": 2}]}
    dst = {"a": [{"x": 10, "z": 3}, {"y": 20, "w": 4}]}
    expected = {"a": [{"x": 1, "z": 3}, {"y": 2, "w": 4}]}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 2.47μs -> 2.39μs (3.39% faster)

def test_basic_list_of_lists_union():
    # Lists of lists are merged element-wise
    src = {"a": [[1, 2], [3, 4]]}
    dst = {"a": [[10, 20], [30, 40]]}
    expected = {"a": [[1, 2], [3, 4]]}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 2.69μs -> 2.46μs (9.46% faster)

def test_source_overwrites_destination_scalar():
    # Scalar in source overwrites any value in destination
    src = {"a": 100}
    dst = {"a": {"nested": 1}}
    expected = {"a": 100}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 818ns -> 821ns (0.365% slower)

def test_destination_is_updated_inplace():
    # The destination dict is updated in-place and also returned
    src = {"a": 1}
    dst = {"b": 2}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), dst); result = codeflash_output # 817ns -> 748ns (9.22% faster)

# 2. Edge Test Cases

def test_empty_source():
    # Empty source should leave destination unchanged
    src = {}
    dst = {"a": 1}
    expected = {"a": 1}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 365ns -> 545ns (33.0% slower)

def test_empty_destination():
    # Empty destination should become a copy of source
    src = {"a": 1}
    dst = {}
    expected = {"a": 1}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 928ns -> 807ns (15.0% faster)

def test_both_empty():
    # Both source and destination empty
    src = {}
    dst = {}
    expected = {}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 347ns -> 518ns (33.0% slower)

def test_source_has_extra_keys():
    # Source has keys not in destination
    src = {"a": 1, "b": 2}
    dst = {"c": 3}
    expected = {"a": 1, "b": 2, "c": 3}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 1.08μs -> 879ns (22.6% faster)

def test_destination_has_extra_keys():
    # Destination has keys not in source
    src = {"a": 1}
    dst = {"a": 2, "b": 3}
    expected = {"a": 1, "b": 3}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 806ns -> 815ns (1.10% slower)

def test_nested_empty_dicts():
    # Source has empty nested dicts
    src = {"a": {}}
    dst = {"a": {"b": 1}}
    expected = {"a": {"b": 1}}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 888ns -> 1.17μs (24.1% slower)

def test_list_length_mismatch_raises():
    # If lists are not the same length, should raise IndexError
    src = {"a": [1, 2]}
    dst = {"a": [3]}
    with pytest.raises(IndexError):
        deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)) # 2.22μs -> 2.19μs (1.41% faster)

def test_list_of_dicts_with_nested_lists():
    # Deeply nested lists and dicts
    src = {"a": [{"b": [1, 2]}, {"c": [3, 4]}]}
    dst = {"a": [{"b": [10, 20]}, {"c": [30, 40]}]}
    expected = {"a": [{"b": [1, 2]}, {"c": [3, 4]}]}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 3.31μs -> 3.13μs (5.62% faster)

def test_source_list_overwrites_destination_nonlist():
    # If source is list and destination is not, should raise TypeError
    src = {"a": [1, 2]}
    dst = {"a": 1}
    with pytest.raises(TypeError):
        deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)) # 2.01μs -> 2.02μs (0.594% slower)

def test_mutation_of_destination_only():
    # Source should not be mutated
    src = {"a": {"b": 1}}
    dst = {"a": {"c": 2}}
    src_copy = copy.deepcopy(src)
    deep_union_pydantic_dicts(src, dst) # 1.50μs -> 1.65μs (9.11% slower)

def test_deeply_nested_structure():
    # Deeply nested dicts and lists
    src = {"a": {"b": {"c": {"d": [1, 2, {"e": 3}]}}}}
    dst = {"a": {"b": {"c": {"d": [4, 5, {"f": 6}]}}}}
    expected = {"a": {"b": {"c": {"d": [1, 2, {"e": 3, "f": 6}]}}}}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 3.29μs -> 3.16μs (4.11% faster)

def test_list_of_lists_with_dicts():
    # Nested lists containing dicts
    src = {"a": [[{"x": 1}], [{"y": 2}]]}
    dst = {"a": [[{"x": 10, "z": 3}], [{"y": 20, "w": 4}]]}
    expected = {"a": [[{"x": 1, "z": 3}], [{"y": 2, "w": 4}]]}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 2.89μs -> 2.72μs (6.28% faster)

def test_handling_of_non_string_keys():
    # Non-string keys are not typical for pydantic, but function should handle them
    src = {1: {"x": 1}}
    dst = {1: {"y": 2}}
    expected = {1: {"x": 1, "y": 2}}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 1.42μs -> 1.44μs (1.05% slower)

# 3. Large Scale Test Cases

def test_large_flat_dict_union():
    # Large flat dicts, 1000 elements each
    src = {f"key{i}": i for i in range(1000)}
    dst = {f"key{i}": -i for i in range(500, 1500)}
    expected = {f"key{i}": i for i in range(1000)}
    expected.update({f"key{i}": -i for i in range(1000, 1500)})
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 89.2μs -> 51.2μs (74.1% faster)

def test_large_nested_dicts():
    # Large dict with nested dicts
    src = {f"outer{i}": {"inner": i} for i in range(500)}
    dst = {f"outer{i}": {"inner": -i, "other": 42} for i in range(500)}
    expected = {f"outer{i}": {"inner": i, "other": 42} for i in range(500)}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 97.3μs -> 92.9μs (4.76% faster)

def test_large_list_of_dicts():
    # Large list of dicts
    src = {"a": [{"x": i} for i in range(300)]}
    dst = {"a": [{"x": -i, "y": 2*i} for i in range(300)]}
    expected = {"a": [{"x": i, "y": 2*i} for i in range(300)]}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 54.0μs -> 49.4μs (9.37% faster)

def test_large_deeply_nested_structure():
    # Large, deeply nested structure
    src = {"root": [{"level1": [{"level2": [i, {"leaf": i*2}]}]} for i in range(50)]}
    dst = {"root": [{"level1": [{"level2": [i+100, {"leaf": -i*2, "extra": 99}]}]} for i in range(50)]}
    expected = {"root": [{"level1": [{"level2": [i, {"leaf": i*2, "extra": 99}]}]} for i in range(50)]}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 41.2μs -> 40.9μs (0.589% faster)

def test_large_dict_with_lists_of_lists():
    # Large dict with lists of lists
    src = {"a": [[i, i+1] for i in range(0, 200, 2)]}
    dst = {"a": [[-i, -(i+1)] for i in range(0, 200, 2)]}
    expected = {"a": [[i, i+1] for i in range(0, 200, 2)]}
    codeflash_output = deep_union_pydantic_dicts(copy.deepcopy(src), copy.deepcopy(dst)); result = codeflash_output # 26.6μs -> 21.3μs (24.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-deep_union_pydantic_dicts-mirfmqzs and push.