⚡️ Speed up method RedisUpdateBuffer._should_commit_spend_updates_to_redis by 8%

[codeflash-ai]

📄 8% (0.08x) speedup for RedisUpdateBuffer._should_commit_spend_updates_to_redis in litellm/proxy/db/db_transaction_queue/redis_update_buffer.py

⏱️ Runtime : 170 microseconds → 157 microseconds (best of 250 runs)

📝 Explanation and details

The optimization replaces set-based membership checking with direct string equality comparisons in the str_to_bool function. The key changes are:

What was optimized:

• Removed true_values = {"true"} and false_values = {"false"} set creations
• Replaced value_lower in true_values with value_lower == "true"
• Replaced value_lower in false_values with value_lower == "false"

Why this is faster:
Since only single values ("true" and "false") are being checked, creating sets and performing membership tests (in operator) adds unnecessary overhead. Direct string equality comparisons (==) are more efficient for single-value comparisons because they avoid:

1. Set object creation and memory allocation
2. Hash computation for membership testing
3. The overhead of the in operator's implementation

Performance impact:
The line profiler shows the str_to_bool function improved from 136.7μs to 103.7μs total time (24% faster). The optimization is particularly effective for string inputs, with test cases showing 10-18% improvements when processing "true"/"false" strings with whitespace.

Hot path relevance:
Based on the function references, _should_commit_spend_updates_to_redis() is called from db_update_spend_transaction_handler(), which handles database transaction commits - a critical performance path. The 8% overall speedup in this function, driven primarily by the str_to_bool optimization, can meaningfully impact database transaction processing latency.

Test case patterns:
The optimization shows consistent gains across all string-based test cases, with the largest improvements (10-30%) occurring when string conversion is needed, making it especially beneficial for configuration parsing scenarios where string values are common.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import sys
import types
# --- Function to test (copied from litellm/proxy/db/db_transaction_queue/redis_update_buffer.py) ---
from typing import Optional, Union

# imports
import pytest
from litellm.proxy.db.db_transaction_queue.redis_update_buffer import \
    RedisUpdateBuffer


# Helper to patch litellm.proxy.proxy_server.general_settings for the duration of a test
class GeneralSettingsPatcher:
    def __init__(self, settings_dict):
        self.settings_dict = settings_dict
        self.module_name = "litellm.proxy.proxy_server"
        self._original_module = None

    def __enter__(self):
        # Create a dummy module if not present
        if self.module_name not in sys.modules:
            sys.modules[self.module_name] = types.ModuleType(self.module_name)
        self._original_module = sys.modules[self.module_name]
        sys.modules[self.module_name].general_settings = self.settings_dict

    def __exit__(self, exc_type, exc_val, exc_tb):
        # Remove the dummy module after test
        if self.module_name in sys.modules:
            del sys.modules[self.module_name]
        # Optionally restore original module if needed (not needed here)

# --- Unit tests for RedisUpdateBuffer._should_commit_spend_updates_to_redis ---
# Basic Test Cases

def test_default_false_if_not_set():
    """Should return False if 'use_redis_transaction_buffer' is not set."""
    with GeneralSettingsPatcher({}):
        codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis() # 2.84μs -> 2.77μs (2.38% faster)

def test_explicit_true_bool():
    """Should return True if 'use_redis_transaction_buffer' is True (bool)."""
    with GeneralSettingsPatcher({"use_redis_transaction_buffer": True}):
        codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis() # 2.77μs -> 2.73μs (1.43% faster)

def test_explicit_false_bool():
    """Should return False if 'use_redis_transaction_buffer' is False (bool)."""
    with GeneralSettingsPatcher({"use_redis_transaction_buffer": False}):
        codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis() # 2.81μs -> 2.69μs (4.46% faster)

def test_explicit_true_str():
    """Should return True if 'use_redis_transaction_buffer' is 'true' (str)."""
    with GeneralSettingsPatcher({"use_redis_transaction_buffer": "true"}):
        codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis() # 3.80μs -> 3.44μs (10.4% faster)

def test_explicit_false_str():
    """Should return False if 'use_redis_transaction_buffer' is 'false' (str)."""
    with GeneralSettingsPatcher({"use_redis_transaction_buffer": "false"}):
        codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis() # 3.67μs -> 3.33μs (10.3% faster)

# Edge Test Cases

def test_str_true_case_insensitive():
    """Should return True for 'TRUE', 'True', ' tRuE ' (case/space insensitivity)."""
    for val in ["TRUE", "True", " tRuE "]:
        with GeneralSettingsPatcher({"use_redis_transaction_buffer": val}):
            codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis()

def test_str_false_case_insensitive():
    """Should return False for 'FALSE', 'False', ' fAlSe ' (case/space insensitivity)."""
    for val in ["FALSE", "False", " fAlSe "]:
        with GeneralSettingsPatcher({"use_redis_transaction_buffer": val}):
            codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis()

def test_str_invalid_value_returns_false():
    """Should return False for unrecognized string values."""
    for val in ["yes", "no", "1", "0", "on", "off", "maybe", "", "   ", "tru"]:
        with GeneralSettingsPatcher({"use_redis_transaction_buffer": val}):
            codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis()

def test_none_value_returns_false():
    """Should return False if the value is None."""
    with GeneralSettingsPatcher({"use_redis_transaction_buffer": None}):
        codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis() # 2.38μs -> 2.29μs (3.79% faster)

def test_explicit_none_key_returns_false():
    """Should return False if the key is present but the value is None."""
    with GeneralSettingsPatcher({"use_redis_transaction_buffer": None}):
        codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis() # 2.35μs -> 2.38μs (0.884% slower)

def test_unexpected_type_returns_false():
    """Should return False for unexpected types (int, float, list, dict)."""
    for val in [123, 0, 1.0, [], {}, object()]:
        with GeneralSettingsPatcher({"use_redis_transaction_buffer": val}):
            # Only bool and str are valid; others should behave as False
            codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis()

def test_explicit_true_str_with_spaces():
    """Should return True if value is ' true ' with leading/trailing spaces."""
    with GeneralSettingsPatcher({"use_redis_transaction_buffer": " true "}):
        codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis() # 3.75μs -> 3.23μs (16.2% faster)

def test_explicit_false_str_with_spaces():
    """Should return False if value is ' false ' with leading/trailing spaces."""
    with GeneralSettingsPatcher({"use_redis_transaction_buffer": " false "}):
        codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis() # 3.80μs -> 3.21μs (18.4% faster)

# Large Scale Test Cases

def test_large_number_of_settings_keys():
    """Should only consider 'use_redis_transaction_buffer' among many keys."""
    settings = {f"dummy_key_{i}": True for i in range(500)}
    settings["use_redis_transaction_buffer"] = True
    with GeneralSettingsPatcher(settings):
        codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis() # 2.60μs -> 2.52μs (3.41% faster)
    settings["use_redis_transaction_buffer"] = False
    with GeneralSettingsPatcher(settings):
        codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis() # 1.65μs -> 1.56μs (5.24% faster)

def test_large_scale_randomized_true_false():
    """Test with 1000 random settings, only 'use_redis_transaction_buffer' matters."""
    # True case
    settings = {f"key_{i}": "true" for i in range(999)}
    settings["use_redis_transaction_buffer"] = "true"
    with GeneralSettingsPatcher(settings):
        codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis() # 4.40μs -> 3.36μs (30.9% faster)
    # False case
    settings["use_redis_transaction_buffer"] = "false"
    with GeneralSettingsPatcher(settings):
        codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis() # 2.23μs -> 1.90μs (17.4% faster)

def test_large_scale_all_false():
    """Test with 1000 keys, all set to False except 'use_redis_transaction_buffer'."""
    settings = {f"key_{i}": False for i in range(999)}
    settings["use_redis_transaction_buffer"] = False
    with GeneralSettingsPatcher(settings):
        codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis() # 2.66μs -> 2.56μs (4.11% faster)

def test_large_scale_all_true():
    """Test with 1000 keys, all set to True except 'use_redis_transaction_buffer'."""
    settings = {f"key_{i}": True for i in range(999)}
    settings["use_redis_transaction_buffer"] = True
    with GeneralSettingsPatcher(settings):
        codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis() # 2.76μs -> 2.67μs (3.60% faster)

def test_large_scale_missing_key():
    """Test with 1000 keys, none are 'use_redis_transaction_buffer'."""
    settings = {f"key_{i}": True for i in range(1000)}
    with GeneralSettingsPatcher(settings):
        codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis() # 2.86μs -> 2.69μs (6.52% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import sys
import types
# str_to_bool implementation (from litellm/secret_managers/main.py)
from typing import Optional, Union

# imports
import pytest
from litellm.proxy.db.db_transaction_queue.redis_update_buffer import \
    RedisUpdateBuffer

# --- Patch setup for tests ---


@pytest.fixture(autouse=True)
def patch_general_settings(monkeypatch):
    """
    Patch litellm.proxy.proxy_server.general_settings for each test.
    """
    # Create a dummy module for litellm.proxy.proxy_server
    proxy_server_mod = types.ModuleType("litellm.proxy.proxy_server")
    proxy_server_mod.general_settings = {}
    sys.modules["litellm.proxy.proxy_server"] = proxy_server_mod
    yield proxy_server_mod.general_settings
    # Clean up after each test
    del sys.modules["litellm.proxy.proxy_server"]

# --- Unit Tests ---

# 1. Basic Test Cases

def test_default_false_when_not_set(patch_general_settings):
    # Scenario: general_settings does not contain the key
    patch_general_settings.clear()
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 2.82μs -> 2.91μs (3.10% slower)

def test_true_when_set_true_bool(patch_general_settings):
    # Scenario: key is set to True (bool)
    patch_general_settings["use_redis_transaction_buffer"] = True
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 2.79μs -> 2.85μs (2.38% slower)

def test_false_when_set_false_bool(patch_general_settings):
    # Scenario: key is set to False (bool)
    patch_general_settings["use_redis_transaction_buffer"] = False
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 2.67μs -> 2.81μs (4.63% slower)

def test_true_when_set_true_string(patch_general_settings):
    # Scenario: key is set to "true" (string)
    patch_general_settings["use_redis_transaction_buffer"] = "true"
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 4.33μs -> 3.68μs (17.8% faster)

def test_false_when_set_false_string(patch_general_settings):
    # Scenario: key is set to "false" (string)
    patch_general_settings["use_redis_transaction_buffer"] = "false"
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 4.01μs -> 3.56μs (12.4% faster)

# 2. Edge Test Cases

def test_none_string_returns_false(patch_general_settings):
    # Scenario: key is set to "none" (string)
    patch_general_settings["use_redis_transaction_buffer"] = "none"
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 3.81μs -> 3.50μs (8.88% faster)

def test_empty_string_returns_false(patch_general_settings):
    # Scenario: key is set to "" (empty string)
    patch_general_settings["use_redis_transaction_buffer"] = ""
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 3.88μs -> 3.54μs (9.56% faster)

def test_whitespace_string_returns_false(patch_general_settings):
    # Scenario: key is set to "   " (whitespace string)
    patch_general_settings["use_redis_transaction_buffer"] = "   "
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 4.03μs -> 3.69μs (9.24% faster)

def test_unrecognized_string_returns_false(patch_general_settings):
    # Scenario: key is set to "yes" (unrecognized string)
    patch_general_settings["use_redis_transaction_buffer"] = "yes"
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 4.01μs -> 3.52μs (13.8% faster)

def test_none_value_returns_false(patch_general_settings):
    # Scenario: key is set to None (explicit None)
    patch_general_settings["use_redis_transaction_buffer"] = None
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 2.74μs -> 2.88μs (4.96% slower)

def test_case_insensitive_true(patch_general_settings):
    # Scenario: key is set to "TrUe" (mixed case)
    patch_general_settings["use_redis_transaction_buffer"] = "TrUe"
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 4.00μs -> 3.61μs (10.9% faster)

def test_case_insensitive_false(patch_general_settings):
    # Scenario: key is set to "FaLsE" (mixed case)
    patch_general_settings["use_redis_transaction_buffer"] = "FaLsE"
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 4.00μs -> 3.62μs (10.5% faster)

def test_true_string_with_spaces(patch_general_settings):
    # Scenario: key is set to "  true  " (leading/trailing spaces)
    patch_general_settings["use_redis_transaction_buffer"] = "  true  "
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 4.04μs -> 3.64μs (11.1% faster)

def test_false_string_with_spaces(patch_general_settings):
    # Scenario: key is set to "  false  " (leading/trailing spaces)
    patch_general_settings["use_redis_transaction_buffer"] = "  false  "
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 3.94μs -> 3.67μs (7.34% faster)

def test_non_bool_type_int_returns_false(patch_general_settings):
    # Scenario: key is set to integer value
    patch_general_settings["use_redis_transaction_buffer"] = 1
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 2.77μs -> 2.67μs (4.01% faster)

def test_non_bool_type_float_returns_false(patch_general_settings):
    # Scenario: key is set to float value
    patch_general_settings["use_redis_transaction_buffer"] = 0.0
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 2.80μs -> 2.61μs (7.00% faster)

def test_non_bool_type_list_returns_false(patch_general_settings):
    # Scenario: key is set to list value
    patch_general_settings["use_redis_transaction_buffer"] = [True]
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 2.72μs -> 2.73μs (0.147% slower)

def test_non_bool_type_dict_returns_false(patch_general_settings):
    # Scenario: key is set to dict value
    patch_general_settings["use_redis_transaction_buffer"] = {"true": True}
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 2.75μs -> 2.67μs (3.00% faster)

# 3. Large Scale Test Cases

def test_large_settings_dict_with_true_key(patch_general_settings):
    # Scenario: general_settings has many keys, only one relevant
    patch_general_settings.clear()
    for i in range(999):
        patch_general_settings[f"dummy_key_{i}"] = False
    patch_general_settings["use_redis_transaction_buffer"] = True
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 2.88μs -> 2.93μs (1.78% slower)

def test_large_settings_dict_with_false_key(patch_general_settings):
    # Scenario: general_settings has many keys, only one relevant
    patch_general_settings.clear()
    for i in range(999):
        patch_general_settings[f"dummy_key_{i}"] = True
    patch_general_settings["use_redis_transaction_buffer"] = False
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 2.98μs -> 3.01μs (0.865% slower)

def test_large_settings_dict_with_true_string_key(patch_general_settings):
    # Scenario: general_settings has many keys, only one relevant as string
    patch_general_settings.clear()
    for i in range(999):
        patch_general_settings[f"dummy_key_{i}"] = "false"
    patch_general_settings["use_redis_transaction_buffer"] = "true"
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 4.43μs -> 3.90μs (13.6% faster)

def test_large_settings_dict_with_false_string_key(patch_general_settings):
    # Scenario: general_settings has many keys, only one relevant as string
    patch_general_settings.clear()
    for i in range(999):
        patch_general_settings[f"dummy_key_{i}"] = "true"
    patch_general_settings["use_redis_transaction_buffer"] = "false"
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 4.13μs -> 3.77μs (9.50% faster)

def test_large_settings_dict_with_unrecognized_key(patch_general_settings):
    # Scenario: general_settings has many keys, relevant key is unrecognized string
    patch_general_settings.clear()
    for i in range(999):
        patch_general_settings[f"dummy_key_{i}"] = "true"
    patch_general_settings["use_redis_transaction_buffer"] = "yes"
    codeflash_output = RedisUpdateBuffer._should_commit_spend_updates_to_redis(); result = codeflash_output # 3.95μs -> 3.51μs (12.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-RedisUpdateBuffer._should_commit_spend_updates_to_redis-mhwqzhoo and push.