⚡️ Speed up function _init_argument by 8%

[codeflash-ai]

📄 8% (0.08x) speedup for _init_argument in sentry_sdk/integrations/stdlib.py

⏱️ Runtime : 55.4 microseconds → 51.5 microseconds (best of 133 runs)

📝 Explanation and details

The optimized version achieves a 7% speedup primarily through reduced callback overhead and improved control flow:

Key Optimizations:

1. Eliminated redundant callback calls: The original code calls setdefault_callback(rv) and then immediately overwrites rv with the result. The optimized version stores the callback result in a separate new_rv variable, only assigning it back to rv if it's not None. This avoids unnecessary variable reassignments.

2. Clearer conditional structure: The optimized version uses explicit if setdefault_callback is not None checks in the final else branch instead of the original's setdefault_callback and setdefault_callback(None) pattern, which was doing boolean evaluation before function calls.

3. Early variable initialization: The rv = None initialization at the start provides a clean baseline and may help with Python's variable scoping optimization.

Performance Profile:

• Best gains on simple lookups without callbacks (14-29% faster on basic arg/kwarg retrieval)
• Minimal overhead on callback cases (0-7% slower when callbacks are used, but this is offset by the reduced redundant operations)
• Excellent performance on large data structures (19-32% faster on large args/kwargs)
• Edge cases like negative indexing and missing arguments see significant improvements (10-24% faster)

The optimization is particularly effective for typical usage patterns where arguments are found by name or position without complex callback transformations, which matches common function wrapping scenarios in the Sentry SDK.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from sentry_sdk.integrations.stdlib import _init_argument

# unit tests

# 1. Basic Test Cases

def test_argument_by_name():
    # Should return the value from kwargs by name
    args = [1, 2]
    kwargs = {'foo': 42}
    codeflash_output = _init_argument(args, kwargs, 'foo', 0); result = codeflash_output # 859ns -> 748ns (14.8% faster)

def test_argument_by_position():
    # Should return the value from args by position if name not in kwargs
    args = [10, 20]
    kwargs = {}
    codeflash_output = _init_argument(args, kwargs, 'bar', 1); result = codeflash_output # 1.04μs -> 911ns (14.7% faster)

def test_argument_by_name_with_callback():
    # Should apply setdefault_callback to value from kwargs
    args = [1, 2]
    kwargs = {'foo': 5}
    def cb(x): return x * 2
    codeflash_output = _init_argument(args, kwargs, 'foo', 0, setdefault_callback=cb); result = codeflash_output # 1.36μs -> 1.37μs (0.947% slower)

def test_argument_by_position_with_callback():
    # Should apply setdefault_callback to value from args
    args = [3, 4]
    kwargs = {}
    def cb(x): return x + 7
    codeflash_output = _init_argument(args, kwargs, 'bar', 1, setdefault_callback=cb); result = codeflash_output # 1.50μs -> 1.54μs (2.79% slower)

def test_argument_not_found_sets_default():
    # If name not in kwargs and position not in args, should use callback(None)
    args = [1]
    kwargs = {}
    def cb(x): return 123 if x is None else x
    codeflash_output = _init_argument(args, kwargs, 'baz', 5, setdefault_callback=cb); result = codeflash_output # 1.40μs -> 1.26μs (11.5% faster)

def test_argument_not_found_no_callback():
    # If name not in kwargs and position not in args, and no callback, returns None
    args = [1]
    kwargs = {}
    codeflash_output = _init_argument(args, kwargs, 'baz', 5); result = codeflash_output # 837ns -> 740ns (13.1% faster)

def test_argument_by_name_callback_returns_none():
    # If callback returns None, should not update kwargs
    args = []
    kwargs = {'foo': 7}
    def cb(x): return None
    codeflash_output = _init_argument(args, kwargs, 'foo', 0, setdefault_callback=cb); result = codeflash_output # 1.02μs -> 1.04μs (2.11% slower)

def test_argument_by_position_callback_returns_none():
    # If callback returns None, should not update args
    args = [9]
    kwargs = {}
    def cb(x): return None
    codeflash_output = _init_argument(args, kwargs, 'bar', 0, setdefault_callback=cb); result = codeflash_output # 1.27μs -> 1.20μs (6.43% faster)

# 2. Edge Test Cases

def test_empty_args_and_kwargs():
    # Both args and kwargs empty, should return callback(None) or None
    args = []
    kwargs = {}
    def cb(x): return 'default'
    codeflash_output = _init_argument(args, kwargs, 'x', 0, setdefault_callback=cb); result = codeflash_output # 1.34μs -> 1.24μs (8.06% faster)

def test_negative_position():
    # Negative position should work for args, like Python negative indexing
    args = [1, 2, 3]
    kwargs = {}
    codeflash_output = _init_argument(args, kwargs, 'foo', -1); result = codeflash_output # 981ns -> 816ns (20.2% faster)
    codeflash_output = _init_argument(args, kwargs, 'foo', -2); result2 = codeflash_output # 615ns -> 475ns (29.5% faster)

def test_position_out_of_range():
    # Position greater than args length, should use callback(None) or None
    args = [1, 2]
    kwargs = {}
    def cb(x): return 'fallback'
    codeflash_output = _init_argument(args, kwargs, 'foo', 10, setdefault_callback=cb); result = codeflash_output # 1.29μs -> 1.20μs (7.78% faster)

def test_name_is_empty_string():
    # Name is empty string, should work as normal key
    args = [1]
    kwargs = {'': 99}
    codeflash_output = _init_argument(args, kwargs, '', 0); result = codeflash_output # 705ns -> 565ns (24.8% faster)

def test_args_and_kwargs_are_mutated_only_on_callback_not_none():
    # Should only mutate args/kwargs if callback returns not None
    args = [1, 2]
    kwargs = {'foo': 3}
    def cb(x): return None
    codeflash_output = _init_argument(args, kwargs, 'foo', 0, setdefault_callback=cb); result = codeflash_output # 985ns -> 983ns (0.203% faster)
    # Now callback returns value
    def cb2(x): return x + 1
    codeflash_output = _init_argument(args, kwargs, 'foo', 0, setdefault_callback=cb2); result2 = codeflash_output # 785ns -> 820ns (4.27% slower)

def test_args_and_kwargs_are_same_object():
    # If args and kwargs are same object (should not happen), function should not crash
    shared = [1, 2]
    codeflash_output = _init_argument(shared, shared, 'foo', 1); result = codeflash_output # 1.14μs -> 963ns (18.6% faster)

def test_kwargs_key_is_int():
    # kwargs key is int, name is str, should not match
    args = [5]
    kwargs = {1: 100}
    codeflash_output = _init_argument(args, kwargs, '1', 0); result = codeflash_output # 969ns -> 801ns (21.0% faster)

def test_callback_raises_exception():
    # If callback raises, function should propagate exception
    args = [1]
    kwargs = {}
    def cb(x): raise ValueError("fail!")
    with pytest.raises(ValueError):
        _init_argument(args, kwargs, 'foo', 0, setdefault_callback=cb) # 1.91μs -> 1.96μs (2.50% slower)

def test_callback_returns_falsey_value():
    # Should update args/kwargs if callback returns 0, '', False, etc (except None)
    args = [5]
    kwargs = {'foo': 8}
    def cb(x): return 0
    codeflash_output = _init_argument(args, kwargs, 'foo', 0, setdefault_callback=cb); result = codeflash_output # 1.21μs -> 1.21μs (0.249% faster)


def test_large_args_list():
    # Large args list, should retrieve correct position efficiently
    args = list(range(1000))
    kwargs = {}
    codeflash_output = _init_argument(args, kwargs, 'foo', 999); result = codeflash_output # 1.24μs -> 1.10μs (12.8% faster)

def test_large_kwargs_dict():
    # Large kwargs dict, should retrieve correct value efficiently
    kwargs = {f'key{i}': i for i in range(1000)}
    args = []
    codeflash_output = _init_argument(args, kwargs, 'key500', 0); result = codeflash_output # 910ns -> 735ns (23.8% faster)

def test_large_args_and_kwargs_with_callback():
    # Large args and kwargs, callback should work and mutate
    args = list(range(1000))
    kwargs = {f'key{i}': i for i in range(1000)}
    def cb(x): return x * 2
    codeflash_output = _init_argument(args, kwargs, 'key999', 999, setdefault_callback=cb); result = codeflash_output # 1.66μs -> 1.69μs (1.60% slower)

def test_large_args_and_kwargs_position_used_when_name_missing():
    # Large args and kwargs, name not present, should use position
    args = list(range(1000))
    kwargs = {f'key{i}': i for i in range(1000)}
    codeflash_output = _init_argument(args, kwargs, 'notfound', 123); result = codeflash_output # 1.12μs -> 913ns (22.8% faster)

def test_large_args_and_kwargs_default_set_when_missing():
    # Large args and kwargs, name not present and position out of range, callback used
    args = list(range(500))
    kwargs = {f'key{i}': i for i in range(500)}
    def cb(x): return 'default-large'
    codeflash_output = _init_argument(args, kwargs, 'notfound', 999, setdefault_callback=cb); result = codeflash_output # 1.36μs -> 1.29μs (5.10% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import pytest  # used for our unit tests
from sentry_sdk.integrations.stdlib import _init_argument

# ===========================
# Unit Tests for _init_argument
# ===========================

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

def test_basic_kwarg_found():
    # If name is in kwargs, should return its value
    args = [1, 2]
    kwargs = {'foo': 42}
    codeflash_output = _init_argument(args, kwargs, 'foo', 0); result = codeflash_output # 704ns -> 570ns (23.5% faster)

def test_basic_arg_found():
    # If name not in kwargs, should return positional argument at position
    args = [99, 88]
    kwargs = {}
    codeflash_output = _init_argument(args, kwargs, 'bar', 1); result = codeflash_output # 1.02μs -> 852ns (20.0% faster)

def test_basic_kwarg_with_setdefault_callback():
    # If setdefault_callback is provided, it should transform the value
    args = []
    kwargs = {'x': 5}
    codeflash_output = _init_argument(args, kwargs, 'x', 0, lambda v: v * 10); result = codeflash_output # 989ns -> 1.06μs (6.87% slower)

def test_basic_arg_with_setdefault_callback():
    # If setdefault_callback is provided, it should transform the positional value
    args = [3, 7]
    kwargs = {}
    codeflash_output = _init_argument(args, kwargs, 'y', 1, lambda v: v + 2); result = codeflash_output # 1.21μs -> 1.26μs (4.20% slower)

def test_basic_setdefault_callback_none():
    # If setdefault_callback returns None, shouldn't update args/kwargs
    args = [100]
    kwargs = {'z': 200}
    codeflash_output = _init_argument(args, kwargs, 'z', 0, lambda v: None); result = codeflash_output # 773ns -> 779ns (0.770% slower)

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

def test_edge_name_not_in_kwargs_and_position_out_of_bounds():
    # Should call setdefault_callback(None) and store in kwargs if not None
    args = [1, 2]
    kwargs = {}
    codeflash_output = _init_argument(args, kwargs, 'missing', 5, lambda v: 'default'); result = codeflash_output # 1.12μs -> 1.01μs (10.7% faster)

def test_edge_name_not_in_kwargs_and_position_out_of_bounds_no_callback():
    # Should return None if no callback and argument not found
    args = [1, 2]
    kwargs = {}
    codeflash_output = _init_argument(args, kwargs, 'missing', 5); result = codeflash_output # 807ns -> 779ns (3.59% faster)

def test_edge_empty_args_and_kwargs():
    # Should handle completely empty inputs
    args = []
    kwargs = {}
    codeflash_output = _init_argument(args, kwargs, 'foo', 0); result = codeflash_output # 840ns -> 745ns (12.8% faster)

def test_edge_negative_position():
    # Should handle negative position (Python supports negative indexing)
    args = [10, 20, 30]
    kwargs = {}
    codeflash_output = _init_argument(args, kwargs, 'foo', -1); result = codeflash_output # 993ns -> 812ns (22.3% faster)

def test_edge_setdefault_callback_returns_none_on_missing():
    # If callback returns None for missing, shouldn't update kwargs
    args = []
    kwargs = {}
    codeflash_output = _init_argument(args, kwargs, 'foo', 0, lambda v: None); result = codeflash_output # 994ns -> 880ns (13.0% faster)

def test_edge_setdefault_callback_returns_none_on_found_arg():
    # If callback returns None for found arg, shouldn't update args
    args = [5]
    kwargs = {}
    codeflash_output = _init_argument(args, kwargs, 'foo', 0, lambda v: None); result = codeflash_output # 949ns -> 1.02μs (7.41% slower)

def test_edge_setdefault_callback_returns_none_on_found_kwarg():
    # If callback returns None for found kwarg, shouldn't update kwargs
    args = []
    kwargs = {'foo': 10}
    codeflash_output = _init_argument(args, kwargs, 'foo', 0, lambda v: None); result = codeflash_output # 772ns -> 771ns (0.130% faster)

def test_edge_mutable_args_and_kwargs_are_updated():
    # Should update mutable args/kwargs in place
    args = [1, 2]
    kwargs = {'foo': 3}
    def cb(v): return v + 100
    _init_argument(args, kwargs, 'foo', 0, cb) # 912ns -> 960ns (5.00% slower)
    _init_argument(args, kwargs, 'bar', 1, cb) # 922ns -> 905ns (1.88% faster)

def test_edge_position_equals_len_args():
    # Should treat position >= len(args) as missing
    args = [1, 2]
    kwargs = {}
    codeflash_output = _init_argument(args, kwargs, 'foo', 2, lambda v: 'fallback'); result = codeflash_output # 1.15μs -> 927ns (23.5% faster)

def test_edge_position_greater_than_len_args():
    # Should treat position > len(args) as missing
    args = [1, 2]
    kwargs = {}
    codeflash_output = _init_argument(args, kwargs, 'foo', 10, lambda v: 'fallback'); result = codeflash_output # 1.13μs -> 989ns (14.3% faster)

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

def test_large_scale_many_args():
    # Should handle large number of positional args
    args = list(range(1000))
    kwargs = {}
    # Pick position 999
    codeflash_output = _init_argument(args, kwargs, 'foo', 999); result = codeflash_output # 1.04μs -> 873ns (19.7% faster)

def test_large_scale_many_kwargs():
    # Should handle large number of kwargs
    args = []
    kwargs = {str(i): i for i in range(1000)}
    codeflash_output = _init_argument(args, kwargs, '500', 0); result = codeflash_output # 807ns -> 725ns (11.3% faster)

def test_large_scale_setdefault_callback_on_missing():
    # Should handle large kwargs and set default if missing
    args = []
    kwargs = {str(i): i for i in range(1000)}
    codeflash_output = _init_argument(args, kwargs, 'notfound', 0, lambda v: 'bigdefault'); result = codeflash_output # 1.19μs -> 970ns (22.7% faster)

def test_large_scale_setdefault_callback_on_found():
    # Should update value in large kwargs using callback
    args = []
    kwargs = {str(i): i for i in range(1000)}
    codeflash_output = _init_argument(args, kwargs, '123', 0, lambda v: v * 2); result = codeflash_output # 1.16μs -> 1.23μs (6.40% slower)

def test_large_scale_args_and_kwargs():
    # Should work when both args and kwargs are large
    args = list(range(1000))
    kwargs = {str(i): i for i in range(1000)}
    # Should pick from kwargs if name found
    codeflash_output = _init_argument(args, kwargs, '999', 999); result = codeflash_output # 849ns -> 719ns (18.1% faster)
    # Should pick from args if name not found
    codeflash_output = _init_argument(args, kwargs, 'notfound', 555); result2 = codeflash_output # 917ns -> 695ns (31.9% faster)

def test_large_scale_setdefault_callback_returns_none():
    # Should not update kwargs if callback returns None
    args = []
    kwargs = {str(i): i for i in range(1000)}
    codeflash_output = _init_argument(args, kwargs, 'notfound', 0, lambda v: None); result = codeflash_output # 1.02μs -> 893ns (14.1% faster)

def test_large_scale_mutable_update():
    # Should update args and kwargs in place for many elements
    args = list(range(1000))
    kwargs = {str(i): i for i in range(1000)}
    def cb(v): return v + 1
    _init_argument(args, kwargs, '500', 500, cb) # 1.10μs -> 1.26μs (12.3% slower)
    _init_argument(args, kwargs, 'notfound', 999, cb) # 1.05μs -> 1.01μs (3.75% faster)

# --------
# Additional Edge Cases
# --------

def test_edge_name_is_empty_string():
    # Should handle empty string as name
    args = [42]
    kwargs = {'': 'empty'}
    codeflash_output = _init_argument(args, kwargs, '', 0); result = codeflash_output # 657ns -> 570ns (15.3% faster)

def test_edge_position_is_zero():
    # Should handle position zero
    args = [77]
    kwargs = {}
    codeflash_output = _init_argument(args, kwargs, 'foo', 0); result = codeflash_output # 1.02μs -> 856ns (18.8% faster)

def test_edge_kwargs_is_none():
    # Should handle kwargs being None (should raise TypeError)
    args = [1, 2]
    kwargs = None
    with pytest.raises(TypeError):
        _init_argument(args, kwargs, 'foo', 0) # 1.79μs -> 1.80μs (0.554% slower)

To edit these changes git checkout codeflash/optimize-_init_argument-mg9ozuw2 and push.