⚡️ Speed up function list_remove_by_value_list by 14%

[codeflash-ai]

📄 14% (0.14x) speedup for list_remove_by_value_list in aerospike_helpers/operations/list_operations.py

⏱️ Runtime : 46.3 microseconds → 40.6 microseconds (best of 5 runs)

📝 Explanation and details

The optimized code achieves a 13% runtime improvement (from 46.3μs to 40.6μs) by eliminating a repeated attribute lookup overhead on every function call.

Key Optimization:
The main change caches the Aerospike operation constant aerospike.OP_LIST_REMOVE_BY_VALUE_LIST as a module-level variable _OP_LIST_REMOVE_BY_VALUE_LIST at import time. This eliminates the need to perform an attribute lookup through the aerospike module namespace on every function invocation.

Why This Improves Performance:
In Python, attribute access (like aerospike.OP_LIST_REMOVE_BY_VALUE_LIST) requires a dictionary lookup in the module's namespace dictionary at runtime. By caching this constant once at module import time and referencing the cached value, we avoid this repeated lookup overhead. The line profiler data shows this optimization reduced the time spent on that specific line from 45,577ns (20.4% of total time) to 38,468ns (17.4% of total time) - a clear reduction in per-call overhead.

Impact on Test Cases:
The optimization provides consistent speedups across all test scenarios:

• 26.3% improvement in the basic operation test
• 20.6% improvement when handling various value_list edge cases
• 19.9% improvement for ctx handling tests
• 6-16% improvements across other edge cases

The gains are most pronounced in simpler test cases where the attribute lookup represents a larger proportion of the total work. All test cases benefit because every invocation eliminates one attribute lookup.

Why This Matters:
This function is likely called frequently when building operation lists for Aerospike database operations. Since it's a lightweight helper that constructs dictionaries, eliminating even a small per-call overhead compounds significantly when called many times in batch operations or hot paths. The optimization is especially valuable for high-throughput scenarios where this function might be invoked thousands of times per second.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 176 Passed
🌀 Generated Regression Tests	✅ 17 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
test_nested_cdt_ctx.py::TestCTXOperations.test_ctx_list_remove_by_value_list	8.43μs	7.19μs	17.3%✅
test_nested_cdt_ctx.py::TestCTXOperations.test_ctx_list_remove_by_value_list_negative	6.03μs	5.54μs	8.86%✅
test_new_list_operation_helpers.py::TestNewListOperationsHelpers.test_remove_by_value_list	1.80μs	1.66μs	8.17%✅
test_new_list_operation_helpers.py::TestNewListOperationsHelpers.test_remove_by_value_list_inverted	2.19μs	2.00μs	9.72%✅

🌀 Click to see Generated Regression Tests

from typing import Optional

# function to test
import aerospike  # used by the function under test and for asserting expected op constant
# imports
import pytest  # used for our unit tests
from aerospike_helpers.operations.list_operations import \
    list_remove_by_value_list

OP_KEY = "op"
BIN_KEY = "bin"
INVERTED_KEY = "inverted"
RETURN_TYPE_KEY = "return_type"
VALUE_LIST_KEY = "value_list"
CTX_KEY = "ctx"

def test_basic_operation_structure_and_values():
    # Basic scenario: typical usage, no ctx, default inverted value (False)
    values = [1, 2, 3]  # sample list of values to remove
    bin_name = "my_bin"  # example bin name
    return_type = 0  # example return type integer

    # Call the function under test
    codeflash_output = list_remove_by_value_list(bin_name, values, return_type); op = codeflash_output # 2.71μs -> 2.15μs (26.3% faster)

def test_inverted_true_and_empty_bin_name_and_negative_return_type():
    # Edge / basic mix: inverted True, empty bin name, negative return type
    values = ["a", "b"]
    bin_name = ""  # empty string for bin name should still be preserved
    return_type = -1  # unusual negative value should be preserved

    codeflash_output = list_remove_by_value_list(bin_name, values, return_type, inverted=True); op = codeflash_output # 2.19μs -> 2.09μs (4.49% faster)

@pytest.mark.parametrize(
    "value_list",
    [
        [],  # empty list - ensure it's preserved and not treated as ctx
        [None],  # list containing None element
        ["dup", "dup", "unique"],  # duplicates preserved
        [1, "1", 1.0],  # mixed types (int, str, float)
    ],
)
def test_value_list_edge_cases_preserved(value_list):
    # Ensure different shapes/content of value_list are preserved as-is in the result
    codeflash_output = list_remove_by_value_list("bin", value_list, 42); op = codeflash_output # 7.13μs -> 5.92μs (20.6% faster)
    if value_list == []:
        pass

def test_ctx_handling_truthy_and_falsey():
    # If ctx is None -> no CTX_KEY
    codeflash_output = list_remove_by_value_list("b", [1], 0, ctx=None); op_none = codeflash_output # 2.16μs -> 1.80μs (19.9% faster)

    # If ctx is an empty list -> evaluated as False in `if ctx:` so no CTX_KEY
    codeflash_output = list_remove_by_value_list("b", [2], 1, ctx=[]); op_empty = codeflash_output # 1.28μs -> 1.15μs (11.0% faster)

    # If ctx is a non-empty list -> CTX_KEY must be present and preserve identity
    ctx_obj = [{"op": "somectx"}]  # using simple dict inside list as a placeholder ctx item
    codeflash_output = list_remove_by_value_list("b", [3], 2, ctx=ctx_obj); op_with_ctx = codeflash_output # 1.21μs -> 1.04μs (16.2% faster)

def test_mutation_of_input_list_reflects_in_returned_dict():
    # The function stores the provided list reference (does not copy).
    src = [1, 2]
    codeflash_output = list_remove_by_value_list("bin", src, 5); op = codeflash_output # 1.63μs -> 1.45μs (12.2% faster)

    # Mutate original source list after calling the function
    src.append(3)

def test_large_value_list_size_and_integrity():
    # Create a large list just under 1000 elements to test scalability
    large_list = list(range(999))  # 999 elements
    codeflash_output = list_remove_by_value_list("big_bin", large_list, 7); op = codeflash_output # 1.71μs -> 1.51μs (13.7% faster)

def test_no_extra_keys_when_ctx_not_provided_and_exact_key_counts():
    # Verify that the function does not add any unexpected keys when ctx is not provided
    values = [10]
    codeflash_output = list_remove_by_value_list("bin", values, 3); op = codeflash_output # 1.69μs -> 1.51μs (11.6% faster)

def test_ctx_inclusion_changes_key_count_to_six():
    # When a non-empty ctx is provided, the dict should include ctx and therefore have 6 keys
    ctx = [{"some": "ctx"}]
    codeflash_output = list_remove_by_value_list("bin", [1], 2, ctx=ctx); op = codeflash_output # 2.35μs -> 2.22μs (6.05% faster)

def test_return_type_pass_through_for_various_integers():
    # Ensure a variety of integers for return_type are passed through unchanged
    for rt in (0, 1, 999, -999):
        codeflash_output = list_remove_by_value_list("bin", [rt], rt); op = codeflash_output # 3.77μs -> 3.38μs (11.4% 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-list_remove_by_value_list-ml0puuum and push.