⚡️ Speed up method OpenrouterConfig._supports_cache_control_in_content by 127%

[codeflash-ai]

📄 127% (1.27x) speedup for OpenrouterConfig._supports_cache_control_in_content in litellm/llms/openrouter/chat/transformation.py

⏱️ Runtime : 16.8 milliseconds → 7.38 milliseconds (best of 80 runs)

📝 Explanation and details

The optimization caches the set of supported model substrings as an instance attribute to avoid repeatedly iterating over the CacheControlSupportedModels enum on every function call.

Key changes:

• Caching mechanism: Added self._cache_control_supported_substrings as an instance attribute that stores the supported model values as a set, computed only once per instance
• Set-based lookup: Changed from iterating through enum values to using set membership (substring in model_lower)

Why this is faster:

• Eliminates repeated enum iteration: The original code iterates through CacheControlSupportedModels on every call (91.8% of runtime), while the optimized version does this only once per instance
• O(1) set membership vs O(n) iteration: Set lookups are constant time, making substring checks much faster than sequential iteration through enum values
• Reduced object allocation: Avoids creating new generators and temporary objects on each function call

Performance characteristics based on tests:

• Large-scale scenarios see biggest gains: Tests with 500+ calls show 89-163% speedup as the caching overhead is amortized
• Single calls are slightly slower initially: Basic test cases show 16-38% slower performance due to the hasattr check and initial set creation overhead
• Best for repeated usage patterns: The optimization shines when the same OpenrouterConfig instance is used multiple times, which is typical in production scenarios

The 127% speedup comes from eliminating the expensive enum iteration that dominated the original implementation's runtime.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from enum import Enum

# imports
import pytest  # used for our unit tests
from litellm.llms.openrouter.chat.transformation import OpenrouterConfig

# function to test (with necessary dependencies defined inline for testability)

class CacheControlSupportedModels(Enum):
    CLAUDE = "claude"
    GEMINI = "gemini"

class OpenAIGPTConfig:
    pass
from litellm.llms.openrouter.chat.transformation import OpenrouterConfig

# unit tests

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

def test_basic_claude_model_name():
    # Should return True for 'claude' model
    config = OpenrouterConfig()
    codeflash_output = config._supports_cache_control_in_content("claude") # 4.46μs -> 6.46μs (30.9% slower)

def test_basic_gemini_model_name():
    # Should return True for 'gemini' model
    config = OpenrouterConfig()
    codeflash_output = config._supports_cache_control_in_content("gemini") # 3.87μs -> 4.83μs (19.8% slower)

def test_basic_non_supported_model():
    # Should return False for a model not containing 'claude' or 'gemini'
    config = OpenrouterConfig()
    codeflash_output = config._supports_cache_control_in_content("gpt-3.5-turbo") # 3.50μs -> 4.66μs (25.0% slower)

def test_basic_supported_in_middle_of_name():
    # Should return True if 'claude' or 'gemini' is a substring
    config = OpenrouterConfig()
    codeflash_output = config._supports_cache_control_in_content("anthropic-claude-v2") # 3.22μs -> 4.84μs (33.4% slower)
    codeflash_output = config._supports_cache_control_in_content("google-gemini-pro") # 2.06μs -> 985ns (110% faster)

def test_basic_case_insensitivity():
    # Should be case-insensitive
    config = OpenrouterConfig()
    codeflash_output = config._supports_cache_control_in_content("CLAUDE") # 2.95μs -> 4.68μs (37.0% slower)
    codeflash_output = config._supports_cache_control_in_content("GeMiNi") # 1.98μs -> 977ns (103% faster)

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

def test_edge_empty_string():
    # Empty string should return False
    config = OpenrouterConfig()
    codeflash_output = config._supports_cache_control_in_content("") # 3.38μs -> 4.48μs (24.5% slower)

def test_edge_partial_match():
    # Partial matches should not trigger True
    config = OpenrouterConfig()
    codeflash_output = config._supports_cache_control_in_content("claud") # 3.44μs -> 4.40μs (21.8% slower)
    codeflash_output = config._supports_cache_control_in_content("gemin") # 1.54μs -> 812ns (89.9% faster)

def test_edge_multiple_supported_models_in_name():
    # Should return True if both supported models are present
    config = OpenrouterConfig()
    model_name = "claude-gemini-mix"
    codeflash_output = config._supports_cache_control_in_content(model_name) # 3.21μs -> 4.51μs (28.8% slower)

def test_edge_supported_model_as_suffix_or_prefix():
    # Should return True if supported model is prefix or suffix
    config = OpenrouterConfig()
    codeflash_output = config._supports_cache_control_in_content("claude-xyz") # 3.11μs -> 4.67μs (33.3% slower)
    codeflash_output = config._supports_cache_control_in_content("xyz-gemini") # 2.09μs -> 861ns (143% faster)

def test_edge_supported_model_with_special_characters():
    # Should return True if supported model is surrounded by special characters
    config = OpenrouterConfig()
    codeflash_output = config._supports_cache_control_in_content("!claude@") # 3.06μs -> 4.67μs (34.5% slower)
    codeflash_output = config._supports_cache_control_in_content("#gemini$") # 1.94μs -> 958ns (103% faster)

def test_edge_supported_model_with_spaces():
    # Spaces should not affect detection
    config = OpenrouterConfig()
    codeflash_output = config._supports_cache_control_in_content("the claude model") # 2.85μs -> 4.66μs (38.9% slower)
    codeflash_output = config._supports_cache_control_in_content("use gemini now") # 2.07μs -> 946ns (118% faster)

def test_edge_supported_model_with_numbers():
    # Numbers in model names should not affect detection
    config = OpenrouterConfig()
    codeflash_output = config._supports_cache_control_in_content("claude2") # 2.87μs -> 4.49μs (36.0% slower)
    codeflash_output = config._supports_cache_control_in_content("gemini-1") # 2.02μs -> 867ns (133% faster)

def test_edge_supported_model_embedded_in_other_word():
    # Should not match if supported model is embedded inside another word
    config = OpenrouterConfig()
    codeflash_output = config._supports_cache_control_in_content("superclaudex") # 3.07μs -> 4.83μs (36.5% slower)
    codeflash_output = config._supports_cache_control_in_content("geminipro") # 2.06μs -> 897ns (130% faster)

def test_edge_supported_model_with_unicode():
    # Unicode should not affect detection if substring is present
    config = OpenrouterConfig()
    codeflash_output = config._supports_cache_control_in_content("claude🚀") # 3.79μs -> 5.53μs (31.4% slower)
    codeflash_output = config._supports_cache_control_in_content("gemini✨") # 2.52μs -> 1.45μs (73.7% faster)

def test_edge_supported_model_with_mixed_case_and_special_characters():
    # Mixed case and special characters should still match
    config = OpenrouterConfig()
    codeflash_output = config._supports_cache_control_in_content("ClAuDe!") # 2.94μs -> 4.71μs (37.6% slower)
    codeflash_output = config._supports_cache_control_in_content("GeMiNi#2024") # 2.00μs -> 918ns (118% faster)

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

def test_large_scale_many_non_supported_models():
    # Test with a large list of non-supported model names
    config = OpenrouterConfig()
    for i in range(1000):
        model_name = f"gpt-model-{i}"
        codeflash_output = config._supports_cache_control_in_content(model_name) # 1.16ms -> 473μs (145% faster)

def test_large_scale_many_supported_models():
    # Test with a large list of supported model names
    config = OpenrouterConfig()
    for i in range(500):
        model_name = f"claude-{i}"
        codeflash_output = config._supports_cache_control_in_content(model_name) # 500μs -> 263μs (89.7% faster)
    for i in range(500):
        model_name = f"gemini-{i}"
        codeflash_output = config._supports_cache_control_in_content(model_name) # 620μs -> 235μs (163% faster)

def test_large_scale_long_model_name_with_supported_model():
    # Test with a very long model name containing supported substring
    config = OpenrouterConfig()
    long_name = "x" * 400 + "claude" + "y" * 400
    codeflash_output = config._supports_cache_control_in_content(long_name) # 4.77μs -> 7.36μs (35.2% slower)

def test_large_scale_long_model_name_without_supported_model():
    # Test with a very long model name not containing supported substring
    config = OpenrouterConfig()
    long_name = "x" * 800
    codeflash_output = config._supports_cache_control_in_content(long_name) # 4.13μs -> 5.47μs (24.5% slower)

def test_large_scale_supported_model_at_various_positions():
    # Test supported model substring at start, middle, end of long string
    config = OpenrouterConfig()
    codeflash_output = config._supports_cache_control_in_content("claude" + "x" * 995) # 3.93μs -> 5.87μs (33.0% slower)
    codeflash_output = config._supports_cache_control_in_content("x" * 495 + "gemini" + "y" * 499) # 2.68μs -> 1.51μs (77.5% faster)
    codeflash_output = config._supports_cache_control_in_content("x" * 995 + "claude") # 1.66μs -> 1.34μs (23.5% faster)


#------------------------------------------------
from enum import Enum

# imports
import pytest
from litellm.llms.openrouter.chat.transformation import OpenrouterConfig


class CacheControlSupportedModels(Enum):
    CLAUDE = "claude"
    GEMINI = "gemini"

class OpenAIGPTConfig:
    pass
from litellm.llms.openrouter.chat.transformation import OpenrouterConfig

# unit tests

@pytest.fixture
def config():
    # Fixture to create an instance of OpenrouterConfig for reuse
    return OpenrouterConfig()

# === Basic Test Cases ===

def test_claude_model_basic(config):
    # Should return True for simple Claude model names
    codeflash_output = config._supports_cache_control_in_content("claude") # 4.19μs -> 6.01μs (30.3% slower)

def test_gemini_model_basic(config):
    # Should return True for simple Gemini model names
    codeflash_output = config._supports_cache_control_in_content("gemini") # 4.04μs -> 5.00μs (19.3% slower)

def test_claude_v2_model(config):
    # Should return True for Claude model variants
    codeflash_output = config._supports_cache_control_in_content("claude-v2") # 3.35μs -> 4.91μs (31.7% slower)

def test_gemini_pro_model(config):
    # Should return True for Gemini model variants
    codeflash_output = config._supports_cache_control_in_content("gemini-pro") # 3.95μs -> 4.72μs (16.5% slower)

def test_non_supported_model_basic(config):
    # Should return False for unrelated model names
    codeflash_output = config._supports_cache_control_in_content("gpt-3.5-turbo") # 3.51μs -> 4.61μs (23.9% slower)

def test_non_supported_model_with_supported_substring(config):
    # Should return False if supported model substring is not present
    codeflash_output = config._supports_cache_control_in_content("turbo-gpt") # 3.39μs -> 4.44μs (23.6% slower)

# === Edge Test Cases ===

def test_case_insensitivity_claude(config):
    # Should be case-insensitive
    codeflash_output = config._supports_cache_control_in_content("ClAuDe") # 3.41μs -> 5.14μs (33.7% slower)

def test_case_insensitivity_gemini(config):
    # Should be case-insensitive
    codeflash_output = config._supports_cache_control_in_content("GeMiNi") # 3.69μs -> 4.64μs (20.4% slower)

def test_model_with_leading_trailing_spaces(config):
    # Should handle leading/trailing spaces
    codeflash_output = config._supports_cache_control_in_content("  claude  ") # 3.15μs -> 4.84μs (34.9% slower)

def test_model_with_supported_substring_in_middle(config):
    # Should match if substring is anywhere in the string
    codeflash_output = config._supports_cache_control_in_content("openrouter-claude-v1") # 3.19μs -> 4.84μs (34.0% slower)

def test_model_with_supported_substring_at_end(config):
    # Should match if substring is at the end
    codeflash_output = config._supports_cache_control_in_content("model-gemini") # 3.73μs -> 4.69μs (20.4% slower)

def test_model_with_supported_substring_at_start(config):
    # Should match if substring is at the start
    codeflash_output = config._supports_cache_control_in_content("claude-model") # 3.02μs -> 4.78μs (36.7% slower)

def test_model_with_multiple_supported_substrings(config):
    # Should match if both substrings are present
    codeflash_output = config._supports_cache_control_in_content("claude-gemini") # 3.13μs -> 4.69μs (33.3% slower)

def test_model_with_supported_substring_embedded(config):
    # Should match if substring is embedded in a longer string
    codeflash_output = config._supports_cache_control_in_content("xxxclaudexxx") # 3.20μs -> 4.77μs (33.0% slower)

def test_empty_string(config):
    # Should return False for empty string
    codeflash_output = config._supports_cache_control_in_content("") # 3.44μs -> 4.42μs (22.0% slower)

def test_whitespace_string(config):
    # Should return False for whitespace-only string
    codeflash_output = config._supports_cache_control_in_content("   ") # 3.17μs -> 4.38μs (27.7% slower)

def test_model_with_special_characters(config):
    # Should match even if special characters surround the substring
    codeflash_output = config._supports_cache_control_in_content("!claude@") # 3.32μs -> 4.87μs (31.8% slower)

def test_model_with_numbered_supported_substring(config):
    # Should match if substring is followed by numbers
    codeflash_output = config._supports_cache_control_in_content("claude123") # 3.09μs -> 4.73μs (34.7% slower)

def test_model_with_supported_substring_in_long_text(config):
    # Should match if substring is in a long text
    codeflash_output = config._supports_cache_control_in_content("this-is-a-long-model-name-with-claude-inside") # 3.29μs -> 4.67μs (29.5% slower)

def test_model_with_supported_substring_as_word_boundary(config):
    # Should match even if substring is at a word boundary
    codeflash_output = config._supports_cache_control_in_content("the model is claude") # 3.31μs -> 4.97μs (33.3% slower)

def test_model_with_supported_substring_with_mixed_case_and_spaces(config):
    # Should match even with mixed case and extra spaces
    codeflash_output = config._supports_cache_control_in_content("  GeMiNi  ") # 3.88μs -> 4.75μs (18.3% slower)

def test_model_with_supported_substring_and_punctuation(config):
    # Should match if substring is followed by punctuation
    codeflash_output = config._supports_cache_control_in_content("claude!") # 3.15μs -> 4.81μs (34.4% slower)

def test_model_with_supported_substring_and_underscore(config):
    # Should match if substring is followed by underscore
    codeflash_output = config._supports_cache_control_in_content("gemini_pro") # 3.68μs -> 4.59μs (19.9% slower)

def test_model_with_supported_substring_and_dash(config):
    # Should match if substring is followed by dash
    codeflash_output = config._supports_cache_control_in_content("claude-pro") # 3.18μs -> 4.91μs (35.2% slower)

def test_model_with_supported_substring_and_multiple_spaces(config):
    # Should match if substring is surrounded by multiple spaces
    codeflash_output = config._supports_cache_control_in_content("   claude   ") # 3.20μs -> 4.69μs (31.8% slower)

def test_model_with_supported_substring_and_tab(config):
    # Should match if substring is surrounded by tabs
    codeflash_output = config._supports_cache_control_in_content("\tclaude\t") # 3.15μs -> 4.73μs (33.4% slower)

def test_model_with_supported_substring_and_newline(config):
    # Should match if substring is surrounded by newlines
    codeflash_output = config._supports_cache_control_in_content("\nclaude\n") # 3.06μs -> 4.73μs (35.3% slower)

def test_model_with_supported_substring_and_unicode(config):
    # Should match if substring is surrounded by unicode characters
    codeflash_output = config._supports_cache_control_in_content("✨claude✨") # 3.79μs -> 5.47μs (30.7% slower)

def test_model_with_supported_substring_and_non_ascii(config):
    # Should match if substring is surrounded by non-ascii characters
    codeflash_output = config._supports_cache_control_in_content("çlaude") # 3.80μs -> 4.68μs (18.8% slower)

def test_model_with_supported_substring_and_multiple_occurrences(config):
    # Should match if substring occurs multiple times
    codeflash_output = config._supports_cache_control_in_content("claude-claude-claude") # 3.27μs -> 4.98μs (34.2% slower)

def test_model_with_supported_substring_and_overlap(config):
    # Should match if substrings overlap
    codeflash_output = config._supports_cache_control_in_content("claudegemini") # 3.10μs -> 4.56μs (31.9% slower)

def test_model_with_supported_substring_and_partial_word(config):
    # Should not match for partial word (e.g. 'claud' or 'gemin')
    codeflash_output = config._supports_cache_control_in_content("claud") # 3.37μs -> 4.28μs (21.4% slower)
    codeflash_output = config._supports_cache_control_in_content("gemin") # 1.61μs -> 899ns (78.8% faster)

def test_model_with_supported_substring_and_false_positive(config):
    # Should not match for unrelated similar substring (e.g. 'cloud')
    codeflash_output = config._supports_cache_control_in_content("cloud") # 3.11μs -> 4.13μs (24.7% slower)

def test_model_with_supported_substring_and_false_positive_gem(config):
    # Should not match for unrelated similar substring (e.g. 'gem')
    codeflash_output = config._supports_cache_control_in_content("gem") # 3.04μs -> 4.00μs (24.1% slower)

def test_model_with_supported_substring_and_false_positive_claude_in_word(config):
    # Should match even if substring is part of a longer word
    codeflash_output = config._supports_cache_control_in_content("superclaudemodel") # 3.48μs -> 5.00μs (30.4% slower)

def test_model_with_supported_substring_and_false_positive_gemini_in_word(config):
    # Should match even if substring is part of a longer word
    codeflash_output = config._supports_cache_control_in_content("ultrageminimodel") # 3.94μs -> 4.55μs (13.5% slower)

def test_model_with_supported_substring_and_false_positive_claude_case(config):
    # Should match if substring is present in any case
    codeflash_output = config._supports_cache_control_in_content("CLAUDE") # 3.12μs -> 4.72μs (33.8% slower)

def test_model_with_supported_substring_and_false_positive_gemini_case(config):
    # Should match if substring is present in any case
    codeflash_output = config._supports_cache_control_in_content("GEMINI") # 3.88μs -> 4.62μs (16.1% slower)

# === Large Scale Test Cases ===

def test_large_scale_supported_models(config):
    # Test with a large list of supported model names
    for i in range(500):
        # Claude models
        codeflash_output = config._supports_cache_control_in_content(f"claude-model-{i}") # 504μs -> 267μs (89.0% faster)
        # Gemini models
        codeflash_output = config._supports_cache_control_in_content(f"gemini-model-{i}")

def test_large_scale_unsupported_models(config):
    # Test with a large list of unsupported model names
    for i in range(500):
        codeflash_output = config._supports_cache_control_in_content(f"gpt-model-{i}") # 596μs -> 244μs (144% faster)
        codeflash_output = config._supports_cache_control_in_content(f"llama-model-{i}")

def test_large_scale_mixed_models(config):
    # Test with a large list of mixed supported and unsupported model names
    for i in range(250):
        codeflash_output = config._supports_cache_control_in_content(f"claude-{i}") # 260μs -> 138μs (88.7% faster)
        codeflash_output = config._supports_cache_control_in_content(f"gemini-{i}")
        codeflash_output = config._supports_cache_control_in_content(f"gpt-{i}") # 324μs -> 124μs (162% faster)
        codeflash_output = config._supports_cache_control_in_content(f"llama-{i}")

def test_large_scale_long_model_names(config):
    # Test with very long model names containing supported substring
    long_prefix = "x" * 100
    long_suffix = "y" * 100
    for i in range(10):
        model_name = f"{long_prefix}claude{long_suffix}{i}"
        codeflash_output = config._supports_cache_control_in_content(model_name) # 14.4μs -> 11.9μs (21.6% faster)
        model_name = f"{long_prefix}gemini{long_suffix}{i}"
        codeflash_output = config._supports_cache_control_in_content(model_name)
        model_name = f"{long_prefix}gpt{long_suffix}{i}" # 15.1μs -> 6.47μs (134% faster)
        codeflash_output = config._supports_cache_control_in_content(model_name)

def test_large_scale_empty_and_whitespace_models(config):
    # Test with many empty and whitespace-only strings
    for _ in range(100):
        codeflash_output = config._supports_cache_control_in_content("") # 122μs -> 51.0μs (140% faster)
        codeflash_output = config._supports_cache_control_in_content("   ")

def test_large_scale_special_characters(config):
    # Test with many model names containing special characters and supported substrings
    specials = "!@#$%^&*()_+-=[]{}|;:',.<>/?`~"
    for i in range(100):
        for s in specials:
            codeflash_output = config._supports_cache_control_in_content(f"{s}claude{s}{i}")
            codeflash_output = config._supports_cache_control_in_content(f"{s}gemini{s}{i}")
            codeflash_output = config._supports_cache_control_in_content(f"{s}gpt{s}{i}")
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from litellm.llms.openrouter.chat.transformation import OpenrouterConfig

def test_OpenrouterConfig__supports_cache_control_in_content():
    OpenrouterConfig._supports_cache_control_in_content(OpenrouterConfig(frequency_penalty=0, function_call={0: 0}, functions=[], logit_bias=None, max_tokens=0, n=0, presence_penalty=0, stop=[0], temperature=0, top_p=0, response_format=None), 'ǔ')

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_kt42dg31/tmp5opuznhq/test_concolic_coverage.py::test_OpenrouterConfig__supports_cache_control_in_content	5.69μs	7.04μs	-19.2%⚠️

To edit these changes git checkout codeflash/optimize-OpenrouterConfig._supports_cache_control_in_content-mhdehn3b and push.