⚡️ Speed up function list_insert_items by 11%

[codeflash-ai]

📄 11% (0.11x) speedup for list_insert_items in aerospike_helpers/operations/list_operations.py

⏱️ Runtime : 115 microseconds → 104 microseconds (best of 5 runs)

📝 Explanation and details

The optimized code achieves a 10% runtime improvement by restructuring the conditional logic to minimize redundant conditional checks.

Key Optimization: Nested Conditional Structure

The original code evaluates both if policy: and if ctx: independently, meaning when policy is truthy, the ctx check still executes unconditionally. The optimized version uses a nested structure:

if policy:
    op_dict[LIST_POLICY_KEY] = policy
    if ctx:
        op_dict[CTX_KEY] = ctx
elif ctx:
    op_dict[CTX_KEY] = ctx

Why This Is Faster:

1. Reduced Branch Evaluations: When policy is truthy (which occurs in ~11% of calls based on test distribution), the ctx check is now nested, avoiding a redundant top-level conditional evaluation. The line profiler shows the second ctx check (line 6 in optimized) executes only 8 times vs 75 times for the original independent check.

2. Branch Prediction Efficiency: The nested structure creates a clearer decision tree - when policy exists, immediately handle both policy and ctx in one branch. When policy doesn't exist, only then check ctx. This pattern is more predictable for CPU branch prediction.

3. Test Results Validation: The optimization performs best when:

   • Both policy and ctx are provided (18.7% faster on test_basic_insert_with_policy_and_ctx)
   • Only ctx is provided (12.7% faster on test_ctx_inclusion_only_when_truthy)
   • Neither are provided (baseline cases show 5-15% improvements)

The minor regression in a few edge cases (like empty policy/ctx) is negligible (<1-2%) and represents normal variance, while the overall 10% runtime improvement demonstrates consistent gains across typical usage patterns where optional parameters are either both present or both absent.

Import Reordering: The secondary change (moving import aerospike after from typing) follows PEP 8 style (standard library before third-party) but has no performance impact.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import sys
import types
from typing import Optional

# function to test
import aerospike
# imports
import pytest  # used for our unit tests
from aerospike_helpers.operations.list_operations import list_insert_items

OP_KEY = "op"
BIN_KEY = "bin"
VALUE_KEY = "val"
INDEX_KEY = "index"
LIST_POLICY_KEY = "list_policy"
CTX_KEY = "ctx"

def test_basic_insert_with_policy_and_ctx():
    # Basic: positive index, non-empty values, non-empty policy and ctx included
    bin_name = "my_bin"
    index = 0
    values = [1, 2, 3]
    policy = {"write_mode": "UPDATE_ONLY"}  # non-empty dict should be included
    ctx = [{"type": "map"}]  # non-empty list should be included

    codeflash_output = list_insert_items(bin_name, index, values, policy=policy, ctx=ctx); op = codeflash_output # 3.55μs -> 2.99μs (18.7% faster)

def test_basic_insert_negative_index_no_policy_no_ctx():
    # Negative index should be accepted and stored as provided; no policy/ctx provided
    bin_name = "neg_bin"
    index = -1
    values = ["a", "b"]

    codeflash_output = list_insert_items(bin_name, index, values); op = codeflash_output # 1.71μs -> 1.67μs (2.64% faster)

def test_empty_policy_and_empty_ctx_are_not_included():
    # Empty dict and empty list are falsey -> function should NOT include them
    bin_name = "edge"
    index = 1
    values = [42]
    empty_policy = {}
    empty_ctx = []

    codeflash_output = list_insert_items(bin_name, index, values, policy=empty_policy, ctx=empty_ctx); op = codeflash_output # 2.02μs -> 2.22μs (9.15% slower)

def test_values_empty_list_still_included():
    # Even though an empty values list is falsey, VALUE_KEY is always set in the op dict
    bin_name = "empty_vals"
    index = 2
    values = []  # empty list

    codeflash_output = list_insert_items(bin_name, index, values); op = codeflash_output # 1.67μs -> 1.47μs (13.4% faster)

def test_none_values_are_stored_as_provided():
    # If values is None, the function will still set the VALUE_KEY to None
    bin_name = "none_vals"
    index = 0
    values = None

    codeflash_output = list_insert_items(bin_name, index, values); op = codeflash_output # 1.63μs -> 1.33μs (22.9% faster)

def test_index_types_preserved_float_and_none():
    # The function does not coerce index types; whatever is passed is stored
    bin_name = "idx_types"
    float_index = 2.5
    none_index = None
    vals = [1]

    codeflash_output = list_insert_items(bin_name, float_index, vals); op_float = codeflash_output # 1.63μs -> 1.42μs (15.0% faster)
    codeflash_output = list_insert_items(bin_name, none_index, vals); op_none = codeflash_output # 896ns -> 787ns (13.9% faster)

def test_mutation_of_values_reflects_in_returned_dict():
    # The function assigns the provided list object directly; subsequent mutation of that list
    # should be visible through the returned operation dict (no defensive copy).
    bin_name = "mutate"
    index = 0
    values = [10, 20]

    codeflash_output = list_insert_items(bin_name, index, values); op = codeflash_output # 1.58μs -> 1.42μs (11.0% faster)

    # Mutate the original list
    values.append(30)

def test_large_scale_values_list_under_1000_elements():
    # Create a large list of size 999 (under the 1000-element constraint)
    bin_name = "large"
    index = 5
    large_values = list(range(999))  # 999 elements

    codeflash_output = list_insert_items(bin_name, index, large_values); op = codeflash_output # 1.59μs -> 1.41μs (12.8% faster)

def test_ctx_inclusion_only_when_truthy():
    # ctx provided as a non-empty list -> must be included
    bin_name = "ctx_bin"
    index = 1
    values = ["x"]
    ctx = [{"some": "ctx"}]

    codeflash_output = list_insert_items(bin_name, index, values, ctx=ctx); op_with_ctx = codeflash_output # 2.37μs -> 2.10μs (12.7% faster)

    # ctx provided as empty list -> must NOT be included
    codeflash_output = list_insert_items(bin_name, index, values, ctx=[]); op_without_ctx = codeflash_output # 876ns -> 885ns (1.02% slower)

def test_policy_truthiness_behavior_with_various_values():
    # Non-empty dict -> included
    p_nonempty = {"action": "insert"}
    codeflash_output = list_insert_items("b", 0, [1], policy=p_nonempty); op1 = codeflash_output # 2.24μs -> 2.03μs (10.3% faster)

    # Empty dict -> not included
    p_empty = {}
    codeflash_output = list_insert_items("b", 0, [1], policy=p_empty); op2 = codeflash_output # 823ns -> 826ns (0.363% slower)

    # Policy as falsy but non-dict (e.g., False) -> should not be included per current truthiness check
    codeflash_output = list_insert_items("b", 0, [1], policy=False); op3 = codeflash_output # 943ns -> 895ns (5.36% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import aerospike
import pytest
from aerospike_helpers.operations.list_operations import list_insert_items

def test_basic_insert_at_beginning():
    """Test inserting items at index 0 (beginning of list)."""
    codeflash_output = list_insert_items("my_bin", 0, [1, 2, 3]); result = codeflash_output # 1.60μs -> 1.51μs (5.48% faster)

def test_basic_insert_in_middle():
    """Test inserting items in the middle of a list."""
    codeflash_output = list_insert_items("numbers", 5, [10, 20, 30]); result = codeflash_output # 1.74μs -> 1.51μs (15.0% faster)

def test_basic_insert_single_item():
    """Test inserting a single item into the list."""
    codeflash_output = list_insert_items("data", 2, [42]); result = codeflash_output # 1.57μs -> 1.47μs (7.22% faster)

def test_basic_insert_multiple_items():
    """Test inserting multiple items at once."""
    values = ["a", "b", "c", "d", "e"]
    codeflash_output = list_insert_items("strings", 1, values); result = codeflash_output # 1.55μs -> 1.50μs (3.81% faster)

def test_basic_insert_with_string_values():
    """Test inserting string values."""
    codeflash_output = list_insert_items("bin_name", 0, ["hello", "world"]); result = codeflash_output # 1.53μs -> 1.35μs (13.3% faster)

def test_basic_insert_with_mixed_types():
    """Test inserting values of mixed types."""
    mixed_values = [1, "two", 3.0, True, None]
    codeflash_output = list_insert_items("mixed", 3, mixed_values); result = codeflash_output # 1.52μs -> 1.37μs (11.4% faster)

def test_basic_insert_with_nested_lists():
    """Test inserting nested list structures."""
    nested_values = [[1, 2], [3, 4, 5], []]
    codeflash_output = list_insert_items("nested", 0, nested_values); result = codeflash_output # 1.68μs -> 1.39μs (20.7% faster)

def test_basic_insert_with_dicts_in_values():
    """Test inserting dictionaries as values."""
    dict_values = [{"key": "value"}, {"number": 42}]
    codeflash_output = list_insert_items("dicts", 1, dict_values); result = codeflash_output # 1.53μs -> 1.34μs (14.3% faster)

def test_edge_negative_index():
    """Test using negative index (indexing from end of list)."""
    codeflash_output = list_insert_items("bin", -1, [100]); result = codeflash_output # 1.53μs -> 1.36μs (13.0% faster)

def test_edge_large_negative_index():
    """Test using large negative index."""
    codeflash_output = list_insert_items("bin", -999, [1, 2, 3]); result = codeflash_output # 1.50μs -> 1.32μs (13.0% faster)

def test_edge_zero_index():
    """Test with index exactly at 0."""
    codeflash_output = list_insert_items("bin", 0, [1]); result = codeflash_output # 1.55μs -> 1.39μs (11.8% faster)

def test_edge_empty_values_list():
    """Test inserting an empty list of values."""
    codeflash_output = list_insert_items("bin", 5, []); result = codeflash_output # 1.59μs -> 1.44μs (10.4% faster)

def test_edge_single_value_in_list():
    """Test with values containing only one element."""
    codeflash_output = list_insert_items("bin", 0, [42]); result = codeflash_output # 1.62μs -> 1.43μs (13.2% faster)

def test_edge_empty_bin_name():
    """Test with empty string as bin name."""
    codeflash_output = list_insert_items("", 0, [1, 2, 3]); result = codeflash_output # 1.50μs -> 1.41μs (6.82% faster)

def test_edge_bin_name_special_characters():
    """Test bin name with special characters."""
    special_bin = "bin_@#$%_special"
    codeflash_output = list_insert_items(special_bin, 0, [1]); result = codeflash_output # 1.58μs -> 1.32μs (19.2% faster)

def test_edge_very_long_bin_name():
    """Test with very long bin name."""
    long_bin = "a" * 500
    codeflash_output = list_insert_items(long_bin, 0, [1]); result = codeflash_output # 1.60μs -> 1.38μs (15.5% faster)

def test_edge_policy_none():
    """Test with policy explicitly set to None."""
    codeflash_output = list_insert_items("bin", 0, [1], policy=None); result = codeflash_output # 2.12μs -> 1.90μs (11.6% faster)

def test_edge_policy_empty_dict():
    """Test with empty policy dictionary."""
    codeflash_output = list_insert_items("bin", 0, [1], policy={}); result = codeflash_output # 2.07μs -> 1.87μs (10.8% faster)

def test_edge_policy_with_values():
    """Test with populated policy dictionary."""
    policy = {"write_flags": 0, "order": 0}
    codeflash_output = list_insert_items("bin", 0, [1], policy=policy); result = codeflash_output # 2.13μs -> 1.84μs (15.5% faster)

def test_edge_ctx_none():
    """Test with context explicitly set to None."""
    codeflash_output = list_insert_items("bin", 0, [1], ctx=None); result = codeflash_output # 1.92μs -> 1.79μs (6.98% faster)

def test_edge_ctx_empty_list():
    """Test with empty context list."""
    codeflash_output = list_insert_items("bin", 0, [1], ctx=[]); result = codeflash_output # 1.98μs -> 1.92μs (3.18% faster)

def test_edge_ctx_with_values():
    """Test with populated context list."""
    ctx = ["some_context_value"]
    codeflash_output = list_insert_items("bin", 0, [1], ctx=ctx); result = codeflash_output # 2.22μs -> 1.96μs (13.2% faster)

def test_edge_both_policy_and_ctx():
    """Test with both policy and context provided."""
    policy = {"option": "value"}
    ctx = ["context_value"]
    codeflash_output = list_insert_items("bin", 5, [1, 2], policy=policy, ctx=ctx); result = codeflash_output # 2.59μs -> 2.31μs (12.5% faster)

def test_edge_large_positive_index():
    """Test with very large positive index."""
    codeflash_output = list_insert_items("bin", 9999999, [1]); result = codeflash_output # 1.55μs -> 1.31μs (18.6% faster)

def test_edge_zero_as_value():
    """Test inserting zero as a value."""
    codeflash_output = list_insert_items("bin", 0, [0]); result = codeflash_output # 1.64μs -> 1.48μs (10.8% faster)

def test_edge_none_as_value():
    """Test inserting None as a value."""
    codeflash_output = list_insert_items("bin", 0, [None]); result = codeflash_output # 1.54μs -> 1.44μs (7.03% faster)

def test_edge_false_as_value():
    """Test inserting False as a value."""
    codeflash_output = list_insert_items("bin", 0, [False]); result = codeflash_output # 1.58μs -> 1.44μs (10.4% faster)

def test_edge_empty_string_as_value():
    """Test inserting empty string as a value."""
    codeflash_output = list_insert_items("bin", 0, [""]); result = codeflash_output # 1.43μs -> 1.33μs (7.59% faster)

def test_edge_floating_point_values():
    """Test inserting floating point numbers."""
    floats = [1.5, -3.14, 0.0, float('inf')]
    codeflash_output = list_insert_items("bin", 0, floats); result = codeflash_output # 1.54μs -> 1.39μs (10.6% faster)

def test_edge_negative_values():
    """Test inserting negative numbers."""
    negatives = [-1, -100, -999999]
    codeflash_output = list_insert_items("bin", 0, negatives); result = codeflash_output # 1.49μs -> 1.41μs (5.60% faster)

def test_large_scale_many_values():
    """Test inserting a large number of values."""
    # Create a list of 500 values to insert
    large_values = list(range(500))
    codeflash_output = list_insert_items("bin", 0, large_values); result = codeflash_output # 1.61μs -> 1.45μs (11.0% faster)

def test_large_scale_large_index():
    """Test with very large index value."""
    codeflash_output = list_insert_items("bin", 1000000, [1, 2, 3]); result = codeflash_output # 1.52μs -> 1.42μs (7.63% faster)

def test_large_scale_large_negative_index():
    """Test with very large negative index."""
    codeflash_output = list_insert_items("bin", -1000000, [1]); result = codeflash_output # 1.65μs -> 1.42μs (16.5% faster)

def test_large_scale_complex_nested_structure():
    """Test inserting complex nested data structures."""
    complex_values = [
        {"nested": {"deep": {"value": i}}, "list": [i, i+1, i+2]}
        for i in range(100)
    ]
    codeflash_output = list_insert_items("bin", 0, complex_values); result = codeflash_output # 1.64μs -> 1.51μs (7.99% faster)

def test_large_scale_large_strings():
    """Test inserting large string values."""
    large_strings = ["x" * 10000 for _ in range(50)]
    codeflash_output = list_insert_items("bin", 0, large_strings); result = codeflash_output # 1.70μs -> 1.45μs (17.4% faster)

def test_large_scale_many_items_at_high_index():
    """Test inserting many items at a high index."""
    many_values = list(range(200))
    codeflash_output = list_insert_items("bin", 50000, many_values); result = codeflash_output # 1.57μs -> 1.39μs (12.6% faster)

def test_large_scale_complex_policy():
    """Test with a complex policy dictionary."""
    large_policy = {f"key_{i}": f"value_{i}" for i in range(100)}
    codeflash_output = list_insert_items("bin", 0, [1], policy=large_policy); result = codeflash_output # 2.47μs -> 2.17μs (13.6% faster)

def test_large_scale_complex_ctx():
    """Test with a large context list."""
    large_ctx = [f"ctx_value_{i}" for i in range(100)]
    codeflash_output = list_insert_items("bin", 0, [1], ctx=large_ctx); result = codeflash_output # 2.22μs -> 2.02μs (10.1% faster)

def test_large_scale_all_parameters_large():
    """Test with large values, index, policy, and context."""
    large_values = list(range(300))
    large_policy = {f"p_{i}": i for i in range(50)}
    large_ctx = [f"c_{i}" for i in range(50)]
    
    codeflash_output = list_insert_items("bin", 500000, large_values, policy=large_policy, ctx=large_ctx); result = codeflash_output # 2.59μs -> 2.23μs (16.5% faster)

def test_return_value_is_dict():
    """Verify that the return value is always a dictionary."""
    codeflash_output = list_insert_items("bin", 0, [1]); result = codeflash_output # 1.60μs -> 1.35μs (18.5% faster)

def test_return_value_contains_required_keys():
    """Verify that basic return value contains all required keys."""
    codeflash_output = list_insert_items("bin", 0, [1]); result = codeflash_output # 1.52μs -> 1.43μs (6.44% faster)

def test_return_value_op_code():
    """Verify the operation code is correct."""
    codeflash_output = list_insert_items("bin", 0, [1]); result = codeflash_output # 1.62μs -> 1.38μs (17.1% faster)

def test_return_value_preserves_input_bin_name():
    """Verify bin name is preserved exactly as input."""
    bin_names = ["simple", "with_underscore", "with123numbers", "CamelCase"]
    
    for bin_name in bin_names:
        codeflash_output = list_insert_items(bin_name, 0, [1]); result = codeflash_output # 3.02μs -> 2.89μs (4.54% faster)

def test_return_value_preserves_input_index():
    """Verify index is preserved exactly as input."""
    indices = [0, 1, -1, 100, -100, 999999]
    
    for idx in indices:
        codeflash_output = list_insert_items("bin", idx, [1]); result = codeflash_output # 4.10μs -> 3.76μs (9.01% faster)

def test_return_value_preserves_input_values():
    """Verify values are preserved exactly as input."""
    test_cases = [
        [1, 2, 3],
        ["a", "b", "c"],
        [1.5, 2.5],
        [None, True, False],
        [[1, 2], [3, 4]],
    ]
    
    for values in test_cases:
        codeflash_output = list_insert_items("bin", 0, values); result = codeflash_output # 3.30μs -> 3.18μs (3.74% faster)

def test_return_value_no_extra_keys_without_policy_ctx():
    """Verify no extra keys in return value when policy and ctx are not provided."""
    codeflash_output = list_insert_items("bin", 0, [1]); result = codeflash_output # 1.48μs -> 1.40μs (5.93% faster)
    
    expected_keys = {"op", "bin", "index", "val"}

def test_return_value_has_policy_key_when_provided():
    """Verify list_policy key exists when policy is provided."""
    codeflash_output = list_insert_items("bin", 0, [1], policy={"key": "value"}); result = codeflash_output # 2.40μs -> 2.00μs (19.8% faster)

def test_return_value_has_ctx_key_when_provided():
    """Verify ctx key exists when context is provided."""
    codeflash_output = list_insert_items("bin", 0, [1], ctx=["value"]); result = codeflash_output # 2.09μs -> 2.06μs (1.40% faster)

def test_return_value_all_keys_when_both_provided():
    """Verify all keys present when both policy and ctx are provided."""
    codeflash_output = list_insert_items("bin", 0, [1], policy={"p": 1}, ctx=["c"]); result = codeflash_output # 2.54μs -> 2.29μs (11.1% faster)
    
    expected_keys = {"op", "bin", "index", "val", "list_policy", "ctx"}
# 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-list_insert_items-ml0liryr and push.