⚡️ Speed up function bit_not by 12%

[codeflash-ai]

📄 12% (0.12x) speedup for bit_not in aerospike_helpers/operations/bitwise_operations.py

⏱️ Runtime : 1.43 milliseconds → 1.28 milliseconds (best of 5 runs)

📝 Explanation and details

The optimization achieves an 11% runtime improvement by caching the aerospike.OP_BIT_NOT constant at module level as _OP_BIT_NOT, eliminating repeated attribute lookups on every function call.

What changed:

• Added a module-level constant _OP_BIT_NOT = aerospike.OP_BIT_NOT that caches the operation type
• Modified the dictionary construction to reference _OP_BIT_NOT instead of aerospike.OP_BIT_NOT

Why this is faster:
In Python, attribute access (aerospike.OP_BIT_NOT) requires traversing the module's namespace dictionary on each invocation. This lookup has measurable overhead, especially in tight loops or frequently called functions. The line profiler shows the attribute lookup line consuming 15.8% of the function's time (1.97ms out of 12.47ms total).

By caching the constant at module import time and using a local name lookup instead, we eliminate the attribute access overhead. Python's LOAD_GLOBAL operation (for _OP_BIT_NOT) is significantly faster than LOAD_ATTR (for aerospike.OP_BIT_NOT) because it avoids the extra level of indirection.

Performance characteristics:
The optimization shows consistent improvements across all test cases:

• Simple calls: 16-40% faster (1.7μs → 1.2μs typical)
• Operations with policy dicts: 16-28% faster
• Large-scale scenarios (500-1000 operations): 7-12% faster in aggregate
• The speedup is most pronounced in the basic dictionary construction path, which benefits directly from faster constant access

Real-world impact:
This function is likely called in hot paths for constructing Aerospike bitwise operations. Since it's a dictionary-building helper that's designed to be called repeatedly when building operation lists, even modest per-call savings compound significantly. The optimization is particularly valuable when:

• Building multiple operations in batch (100-1000+ operations)
• Called in request processing loops
• Used in performance-critical data processing pipelines

The change is purely internal (caching strategy) with no API or behavioral changes, making it safe and backward-compatible.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 139 Passed
🌀 Generated Regression Tests	✅ 3280 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_bitwise_operations.py::TestBitwiseOperations.test_bit_not	1.85μs	1.45μs	27.7%✅
test_bitwise_operations.py::TestBitwiseOperations.test_bit_not_bad_arg	1.66μs	1.31μs	26.9%✅
test_bitwise_operations.py::TestBitwiseOperations.test_bit_not_bad_bin_name	1.65μs	1.28μs	28.5%✅
test_bitwise_operations.py::TestBitwiseOperations.test_bit_not_bit_size_too_large	1.74μs	1.37μs	26.8%✅
test_bitwise_operations.py::TestBitwiseOperations.test_bit_not_offset_out_of_range	1.68μs	1.25μs	34.3%✅
test_bitwise_operations.py::TestBitwiseOperations.test_bit_not_small_bit_size	1.79μs	1.34μs	32.9%✅

🌀 Click to see Generated Regression Tests

import sys
import types

import pytest  # used for our unit tests
from aerospike_helpers.operations.bitwise_operations import bit_not

# Ensure an 'aerospike' module is available for the tested function.
# If the real aerospike package is installed in the test environment, use it.
# If not, create a minimal stand-in module that provides the single constant used
# by the function (OP_BIT_NOT). This is necessary so the function definition
# (which references aerospike.OP_BIT_NOT) can be executed without ImportError.
try:
    import aerospike  # try to import the real aerospike package
except Exception:
    # Create a minimal module with the constant we need.
    aerospike = types.ModuleType("aerospike")

# function to test
# (Preserve the original function exactly as provided.)
BIN_KEY = "bin"
BIT_OFFSET_KEY = "bit_offset"
BIT_SIZE_KEY = "bit_size"
OP_KEY = "op"
POLICY_KEY = "policy"

def test_basic_structure_and_values():
    # Basic test: ensure returned object is a dict with the exact expected keys.
    codeflash_output = bit_not("my_bin", 10, 8); result = codeflash_output # 1.66μs -> 1.27μs (31.0% faster)

def test_preserves_policy_object_identity_and_contents():
    # Edge: pass a non-empty policy dict and ensure the same object reference is stored.
    policy = {"invert": True, "ignore_out_of_range": False}
    codeflash_output = bit_not("b", 0, 1, policy=policy); result = codeflash_output # 2.04μs -> 1.68μs (21.9% faster)
    # Mutating the policy outside should be visible inside the returned dict (same ref).
    policy["new_key"] = "value"

@pytest.mark.parametrize(
    "bin_name_value",
    [
        "",  # empty string bin names should be preserved
        b"bytes_bin",  # bytes as bin name should be preserved unchanged
        123,  # non-string bin_name (int) should be preserved as-is (function does not enforce types)
        True,  # boolean (subclass of int) should be preserved
    ],
)
def test_various_bin_name_types_are_preserved(bin_name_value):
    # For each bin_name variant, ensure the returned dict contains the exact same object/value.
    codeflash_output = bit_not(bin_name_value, 5, 2); result = codeflash_output # 6.54μs -> 5.04μs (29.8% faster)

@pytest.mark.parametrize(
    "offset,size",
    [
        (0, 0),  # zero offset and size
        (-1, 1),  # negative offset preserved (no validation done by function)
        (1, -1),  # negative size preserved
        (2**200, 64),  # very large offset integer preserved exactly
        (3.1415, 2.718),  # floating point values preserved as-is
        (None, None),  # None for offset/size preserved as-is
        (True, False),  # booleans as offset/size preserved as-is
    ],
)
def test_bit_offset_and_size_preservation(offset, size):
    # The function should preserve whatever values are passed for offset and size.
    codeflash_output = bit_not("binX", offset, size); result = codeflash_output # 11.5μs -> 8.83μs (29.7% faster)

def test_missing_required_arguments_raises_type_error():
    # The function signature requires at least 3 positional args (bin_name, bit_offset, bit_size).
    # Omitting required args should raise TypeError from Python before the function body runs.
    with pytest.raises(TypeError):
        # Missing bit_size
        bit_not("only_bin_and_offset", 5) # 4.30μs -> 4.38μs (1.71% slower)

def test_large_scale_policy_reference_and_integrity():
    # Large scale: create a big policy with 500 entries to check handling of large dicts.
    # Keep under 1000 elements as per instructions.
    large_policy = {f"key_{i}": i for i in range(500)}
    codeflash_output = bit_not("big_bin", 100, 200, policy=large_policy); result = codeflash_output # 2.36μs -> 1.84μs (28.4% faster)
    # Ensure all entries are present in the returned policy reference.
    for i in (0, 100, 499):  # spot-check a few indices (no loop >1000)
        pass

def test_mutating_return_values_behaviour():
    # Verify that mutating the returned top-level dict does not alter the original scalar args.
    bin_name = "immutable_bin"
    policy = {"a": 1}
    codeflash_output = bit_not(bin_name, 7, 3, policy=policy); result = codeflash_output # 1.99μs -> 1.73μs (15.3% faster)
    # Change returned dict's bin value
    result[BIN_KEY] = "modified"
    # But the policy object is the same reference, so mutating it via result affects the original.
    result[POLICY_KEY]["b"] = 2

def test_op_key_is_not_a_string_typo_detection():
    # Mutation testing guard: ensure the OP_KEY constant is present and used, to detect accidental renames.
    codeflash_output = bit_not("guard_bin", 1, 1); res = codeflash_output # 1.51μs -> 1.26μs (19.2% 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.bitwise_operations import bit_not

class TestBitNotBasicFunctionality:
    """Test basic functionality of bit_not with standard inputs."""

    def test_simple_bin_with_basic_offset_and_size(self):
        """Test basic bit_not operation with simple parameters."""
        codeflash_output = bit_not("bin1", 0, 8); result = codeflash_output # 1.75μs -> 1.44μs (21.7% faster)

    def test_bit_not_returns_dict_with_required_keys(self):
        """Test that bit_not returns a dict with all required keys."""
        codeflash_output = bit_not("test_bin", 0, 8); result = codeflash_output # 1.72μs -> 1.36μs (26.0% faster)

    def test_bit_not_op_value_is_correct(self):
        """Test that the operation key has the correct aerospike constant."""
        codeflash_output = bit_not("bin1", 0, 8); result = codeflash_output # 1.68μs -> 1.26μs (33.5% faster)

    def test_bit_not_bin_name_preserved(self):
        """Test that the bin name is correctly preserved in the result."""
        bin_name = "my_bitmap"
        codeflash_output = bit_not(bin_name, 0, 8); result = codeflash_output # 1.68μs -> 1.22μs (38.0% faster)

    def test_bit_not_bit_offset_preserved(self):
        """Test that the bit_offset is correctly preserved in the result."""
        offset = 5
        codeflash_output = bit_not("bin1", offset, 8); result = codeflash_output # 1.56μs -> 1.29μs (20.6% faster)

    def test_bit_not_bit_size_preserved(self):
        """Test that the bit_size is correctly preserved in the result."""
        size = 16
        codeflash_output = bit_not("bin1", 0, size); result = codeflash_output # 1.54μs -> 1.32μs (16.6% faster)

    def test_bit_not_with_none_policy(self):
        """Test bit_not with None as the policy parameter."""
        codeflash_output = bit_not("bin1", 0, 8, policy=None); result = codeflash_output # 2.32μs -> 1.96μs (18.0% faster)

    def test_bit_not_without_policy_parameter(self):
        """Test bit_not without providing the policy parameter."""
        codeflash_output = bit_not("bin1", 0, 8); result = codeflash_output # 1.77μs -> 1.26μs (39.7% faster)

    def test_bit_not_with_dict_policy(self):
        """Test bit_not with an actual policy dictionary."""
        policy = {"flags": 0}
        codeflash_output = bit_not("bin1", 0, 8, policy=policy); result = codeflash_output # 2.27μs -> 1.96μs (16.1% faster)

    def test_bit_not_various_bin_names(self):
        """Test bit_not with various valid bin names."""
        bin_names = ["bin1", "data", "bitmap", "flags", "x"]
        for bin_name in bin_names:
            codeflash_output = bit_not(bin_name, 0, 8); result = codeflash_output # 3.68μs -> 3.07μs (19.9% faster)

    def test_bit_not_various_offsets(self):
        """Test bit_not with various offset values."""
        offsets = [0, 1, 8, 16, 32, 64, 100, 1000]
        for offset in offsets:
            codeflash_output = bit_not("bin1", offset, 8); result = codeflash_output # 4.99μs -> 4.38μs (14.0% faster)

    def test_bit_not_various_sizes(self):
        """Test bit_not with various bit size values."""
        sizes = [1, 8, 16, 32, 64, 128, 256]
        for size in sizes:
            codeflash_output = bit_not("bin1", 0, size); result = codeflash_output # 4.34μs -> 3.79μs (14.5% faster)

class TestBitNotEdgeCases:
    """Test edge cases and boundary conditions."""

    def test_bit_not_zero_bit_size(self):
        """Test bit_not with zero bit_size."""
        codeflash_output = bit_not("bin1", 0, 0); result = codeflash_output # 1.50μs -> 1.26μs (18.8% faster)

    def test_bit_not_very_large_bit_offset(self):
        """Test bit_not with a very large bit_offset."""
        large_offset = 1000000
        codeflash_output = bit_not("bin1", large_offset, 8); result = codeflash_output # 1.66μs -> 1.37μs (21.2% faster)

    def test_bit_not_very_large_bit_size(self):
        """Test bit_not with a very large bit_size."""
        large_size = 1000000
        codeflash_output = bit_not("bin1", 0, large_size); result = codeflash_output # 1.67μs -> 1.30μs (28.1% faster)

    def test_bit_not_empty_string_bin_name(self):
        """Test bit_not with an empty string as bin name."""
        codeflash_output = bit_not("", 0, 8); result = codeflash_output # 1.57μs -> 1.28μs (22.2% faster)

    def test_bit_not_special_characters_in_bin_name(self):
        """Test bit_not with special characters in bin name."""
        special_names = ["bin-1", "bin_2", "bin.3", "bin@4", "bin#5"]
        for name in special_names:
            codeflash_output = bit_not(name, 0, 8); result = codeflash_output # 3.89μs -> 3.46μs (12.5% faster)

    def test_bit_not_numeric_string_bin_name(self):
        """Test bit_not with numeric string as bin name."""
        codeflash_output = bit_not("123", 0, 8); result = codeflash_output # 1.64μs -> 1.10μs (49.2% faster)

    def test_bit_not_long_bin_name(self):
        """Test bit_not with a very long bin name."""
        long_name = "bin" * 100  # 300 characters
        codeflash_output = bit_not(long_name, 0, 8); result = codeflash_output # 1.59μs -> 1.24μs (28.7% faster)

    def test_bit_not_with_empty_policy_dict(self):
        """Test bit_not with an empty dictionary as policy."""
        codeflash_output = bit_not("bin1", 0, 8, policy={}); result = codeflash_output # 2.10μs -> 1.85μs (13.7% faster)

    def test_bit_not_with_complex_policy_dict(self):
        """Test bit_not with a complex policy dictionary."""
        policy = {"flags": 1, "read_timeout_ms": 1000}
        codeflash_output = bit_not("bin1", 0, 8, policy=policy); result = codeflash_output # 2.08μs -> 1.75μs (19.1% faster)

    def test_bit_not_offset_and_size_sum_large(self):
        """Test bit_not where offset + size results in a large number."""
        offset = 1000
        size = 1000
        codeflash_output = bit_not("bin1", offset, size); result = codeflash_output # 1.67μs -> 1.36μs (22.8% faster)

    def test_bit_not_negative_offset(self):
        """Test bit_not with negative offset (if supported)."""
        codeflash_output = bit_not("bin1", -1, 8); result = codeflash_output # 1.54μs -> 1.29μs (19.4% faster)

    def test_bit_not_negative_size(self):
        """Test bit_not with negative size (if supported)."""
        codeflash_output = bit_not("bin1", 0, -1); result = codeflash_output # 1.61μs -> 1.35μs (18.9% faster)

    def test_bit_not_both_offsets_and_sizes_negative(self):
        """Test bit_not with both negative offset and size."""
        codeflash_output = bit_not("bin1", -5, -10); result = codeflash_output # 1.59μs -> 1.29μs (23.6% faster)

    def test_bit_not_unicode_bin_name(self):
        """Test bit_not with unicode characters in bin name."""
        unicode_name = "bin_\u00e9\u00f1"  # bin_éñ
        codeflash_output = bit_not(unicode_name, 0, 8); result = codeflash_output # 1.56μs -> 1.33μs (16.9% faster)

class TestBitNotLargeScale:
    """Test large scale scenarios and performance characteristics."""

    def test_bit_not_many_consecutive_operations(self):
        """Test generating many bit_not operations."""
        operations = []
        for i in range(500):
            codeflash_output = bit_not(f"bin{i}", i, i + 1); op = codeflash_output # 203μs -> 183μs (11.1% faster)
            operations.append(op)
        # Verify that all operations have correct structure
        for i, op in enumerate(operations):
            pass

    def test_bit_not_with_extremely_large_offset(self):
        """Test bit_not with extremely large offset value."""
        large_offset = 10**9
        codeflash_output = bit_not("bin1", large_offset, 8); result = codeflash_output # 1.75μs -> 1.40μs (25.0% faster)

    def test_bit_not_with_extremely_large_size(self):
        """Test bit_not with extremely large size value."""
        large_size = 10**9
        codeflash_output = bit_not("bin1", 0, large_size); result = codeflash_output # 1.69μs -> 1.29μs (31.2% faster)

    def test_bit_not_operation_list_consistency(self):
        """Test that multiple operations maintain consistent structure."""
        ops = [bit_not("bin1", i * 10, i + 8) for i in range(100)]
        # All should have same keys
        keys = set(ops[0].keys())
        for op in ops:
            pass

    def test_bit_not_rapid_sequential_calls(self):
        """Test that rapid sequential calls work correctly."""
        results = []
        for i in range(500):
            codeflash_output = bit_not("bin", i, 1); result = codeflash_output # 201μs -> 180μs (11.6% faster)
            results.append(result)
        # Verify all have correct op type
        for result in results:
            pass

    def test_bit_not_varying_parameters_large_scale(self):
        """Test varying all parameters in large scale."""
        results = []
        for bin_idx in range(10):
            for offset in range(0, 100, 10):
                for size in range(1, 50, 5):
                    codeflash_output = bit_not(f"bin{bin_idx}", offset, size); result = codeflash_output
                    results.append(result)
        # Verify structure
        for result in results:
            pass

    def test_bit_not_with_various_policy_dicts_scale(self):
        """Test bit_not with various policy dictionaries at scale."""
        policies = [
            None,
            {},
            {"flags": 0},
            {"flags": 1},
            {"read_timeout_ms": 1000},
            {"flags": 2, "read_timeout_ms": 5000},
        ]
        results = []
        for i in range(200):
            policy = policies[i % len(policies)]
            codeflash_output = bit_not("bin1", i, 8, policy=policy); result = codeflash_output # 99.5μs -> 92.2μs (7.89% faster)
            results.append(result)
        # Verify policies are correctly assigned
        for i, result in enumerate(results):
            expected_policy = policies[i % len(policies)]

    def test_bit_not_memory_efficiency_large_operations(self):
        """Test that creating large number of operations is memory efficient."""
        # Create 1000 operations and verify they can be created without issues
        ops = []
        for i in range(1000):
            codeflash_output = bit_not(f"bin_{i % 100}", i * 10, 8); op = codeflash_output # 404μs -> 362μs (11.5% faster)
            ops.append(op)

    def test_bit_not_extreme_combined_values(self):
        """Test bit_not with extreme combinations of offset and size."""
        extreme_cases = [
            (0, 10**8),
            (10**8, 0),
            (10**7, 10**7),
            (10**9, 10**9),
        ]
        for offset, size in extreme_cases:
            codeflash_output = bit_not("bin1", offset, size); result = codeflash_output # 3.75μs -> 3.15μs (19.1% faster)

class TestBitNotReturnStructure:
    """Test the structure and type of returned values."""

    def test_bit_not_return_type_is_dict(self):
        """Test that bit_not returns a dictionary."""
        codeflash_output = bit_not("bin1", 0, 8); result = codeflash_output # 1.57μs -> 1.33μs (17.8% faster)

    def test_bit_not_dict_has_exactly_five_keys(self):
        """Test that the returned dict has exactly 5 keys."""
        codeflash_output = bit_not("bin1", 0, 8); result = codeflash_output # 1.62μs -> 1.31μs (23.2% faster)

    def test_bit_not_dict_keys_are_strings(self):
        """Test that all dictionary keys are strings."""
        codeflash_output = bit_not("bin1", 0, 8); result = codeflash_output # 1.60μs -> 1.26μs (27.3% faster)
        for key in result.keys():
            pass

    def test_bit_not_dict_key_values_correct_types(self):
        """Test that dictionary values have correct types."""
        codeflash_output = bit_not("bin1", 0, 8, policy={"flags": 1}); result = codeflash_output # 2.00μs -> 1.82μs (9.67% faster)

    def test_bit_not_immutability_of_returned_dict(self):
        """Test that we can modify the returned dict without affecting future calls."""
        codeflash_output = bit_not("bin1", 0, 8); result1 = codeflash_output # 1.61μs -> 1.24μs (30.5% faster)
        original_bin = result1["bin"]
        result1["bin"] = "modified"
        codeflash_output = bit_not("bin1", 0, 8); result2 = codeflash_output # 638ns -> 630ns (1.27% faster)

    def test_bit_not_multiple_calls_independence(self):
        """Test that multiple calls return independent dictionaries."""
        codeflash_output = bit_not("bin1", 0, 8); result1 = codeflash_output # 1.61μs -> 1.28μs (25.8% faster)
        codeflash_output = bit_not("bin1", 0, 8); result2 = codeflash_output # 603ns -> 611ns (1.31% slower)

    def test_bit_not_bin_offset_size_in_result(self):
        """Test that bin_name, bit_offset, and bit_size are stored with correct keys."""
        bin_name = "test_bin"
        offset = 42
        size = 16
        codeflash_output = bit_not(bin_name, offset, size); result = codeflash_output # 1.55μs -> 1.22μs (27.1% 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-bit_not-ml0k3tk2 and push.