⚡️ Speed up function get_provider_from_variable_name by 104% in PR #10565 (model-provider-keys-v2)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #10565

If you approve this dependent PR, these changes will be merged into the original PR branch model-provider-keys-v2.

This PR will be automatically closed if the original PR is merged.

---

📄 104% (1.04x) speedup for get_provider_from_variable_name in src/backend/base/langflow/api/v1/models.py

⏱️ Runtime : 80.6 microseconds → 39.6 microseconds (best of 166 runs)

📝 Explanation and details

The optimized version achieves a 103% speedup by replacing a linear search through a dictionary with a direct hash table lookup.

Key optimization applied:

• Eliminated O(n) linear search: The original code iterates through all provider-variable pairs using for provider, var_name in provider_mapping.items() until finding a match
• Introduced O(1) hash lookup: The optimized version pre-computes a reversed mapping {var_name: provider} and uses dict.get(variable_name) for constant-time lookups
• Added memoization with @lru_cache(maxsize=1): The reversed mapping is cached so it's only computed once, even across multiple function calls

Why this leads to speedup:
In Python, dictionary .get() operations are O(1) average case, while iterating through dictionary items is O(n). The line profiler shows the original code spent 46.5% of time in the loop iteration and 29.1% in string comparisons. The optimized version eliminates both, reducing total runtime from 620μs to 119μs.

Performance characteristics based on test results:

• Small mappings (8-10 providers): Consistent ~2x speedup across all test cases
• Large mappings (1000 providers): The speedup becomes more pronounced as the linear search penalty increases
• Cache effectiveness: The lru_cache ensures that even repeated calls to get_model_provider_variable_mapping() don't impact performance after the first call

This optimization is particularly valuable when get_provider_from_variable_name is called frequently with large provider mappings, transforming what was potentially an expensive operation into a near-constant time lookup.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from langflow.api.v1.models import get_provider_from_variable_name


# --- Function to test ---
# Simulate get_model_provider_variable_mapping for testing purposes.
def get_model_provider_variable_mapping():
    # Example realistic mapping for testing
    return {
        "OpenAI": "OPENAI_API_KEY",
        "Anthropic": "ANTHROPIC_API_KEY",
        "Google": "GOOGLE_API_KEY",
        "Azure": "AZURE_API_KEY",
        "Cohere": "COHERE_API_KEY",
        "HuggingFace": "HUGGINGFACE_API_TOKEN",
        "AWS": "AWS_ACCESS_KEY",
        "CustomProvider": "CUSTOMPROVIDER_SECRET",
        # Add more for large scale test below
    }
from langflow.api.v1.models import get_provider_from_variable_name

# --- Unit tests ---

# 1. Basic Test Cases

def test_basic_known_provider():
    # Test with known variable names
    codeflash_output = get_provider_from_variable_name("OPENAI_API_KEY")
    codeflash_output = get_provider_from_variable_name("ANTHROPIC_API_KEY")
    codeflash_output = get_provider_from_variable_name("GOOGLE_API_KEY")
    codeflash_output = get_provider_from_variable_name("AZURE_API_KEY")
    codeflash_output = get_provider_from_variable_name("COHERE_API_KEY")
    codeflash_output = get_provider_from_variable_name("HUGGINGFACE_API_TOKEN")
    codeflash_output = get_provider_from_variable_name("AWS_ACCESS_KEY")
    codeflash_output = get_provider_from_variable_name("CUSTOMPROVIDER_SECRET")

def test_basic_unknown_provider():
    # Test with variable names not in the mapping
    codeflash_output = get_provider_from_variable_name("NOT_A_PROVIDER_KEY")
    codeflash_output = get_provider_from_variable_name("OPENAI_KEY")
    codeflash_output = get_provider_from_variable_name("GOOGLE_SECRET")
    codeflash_output = get_provider_from_variable_name("AZURE_TOKEN")

def test_basic_none_and_empty_string():
    # Test with None and empty string (should return None)
    codeflash_output = get_provider_from_variable_name("")
    # None is not a valid input type, but let's check that it raises TypeError
    with pytest.raises(TypeError):
        get_provider_from_variable_name(None)

def test_basic_case_sensitivity():
    # Test that variable name matching is case-sensitive
    codeflash_output = get_provider_from_variable_name("openai_api_key")
    codeflash_output = get_provider_from_variable_name("OPENAI_api_KEY")
    codeflash_output = get_provider_from_variable_name("OPENAI_API_KEY")

# 2. Edge Test Cases

def test_edge_whitespace():
    # Leading/trailing whitespace should not match
    codeflash_output = get_provider_from_variable_name(" OPENAI_API_KEY")
    codeflash_output = get_provider_from_variable_name("OPENAI_API_KEY ")
    codeflash_output = get_provider_from_variable_name("  OPENAI_API_KEY  ")

def test_edge_partial_match():
    # Partial matches should not return a provider
    codeflash_output = get_provider_from_variable_name("OPENAI_API")
    codeflash_output = get_provider_from_variable_name("API_KEY")
    codeflash_output = get_provider_from_variable_name("ANTHROPIC")

def test_edge_special_characters():
    # Variable names with special characters
    codeflash_output = get_provider_from_variable_name("OPENAI_API_KEY!")
    codeflash_output = get_provider_from_variable_name("OPENAI_API_KEY@")
    codeflash_output = get_provider_from_variable_name("HUGGINGFACE_API_TOKEN$")

def test_edge_duplicate_variable_names():
    # Simulate mapping with duplicate variable names for different providers
    def get_model_provider_variable_mapping_dup():
        return {
            "OpenAI": "OPENAI_API_KEY",
            "FakeOpenAI": "OPENAI_API_KEY",  # Duplicate variable name
            "Anthropic": "ANTHROPIC_API_KEY",
        }
    # Patch the function locally
    global get_model_provider_variable_mapping
    old_mapping = get_model_provider_variable_mapping
    get_model_provider_variable_mapping = get_model_provider_variable_mapping_dup
    # Should return the first provider found with the variable name
    codeflash_output = get_provider_from_variable_name("OPENAI_API_KEY"); result = codeflash_output
    # Restore original mapping
    get_model_provider_variable_mapping = old_mapping


def test_edge_long_variable_name():
    # Very long variable name that doesn't exist
    long_var_name = "A" * 1000
    codeflash_output = get_provider_from_variable_name(long_var_name)

def test_edge_unicode_characters():
    # Unicode characters in variable name
    codeflash_output = get_provider_from_variable_name("OPENAI_API_KEY😀")
    codeflash_output = get_provider_from_variable_name("HUGGINGFACE_API_TOKENé")

# 3. Large Scale Test Cases

def test_large_scale_many_providers():
    # Create a large mapping of 1000 providers
    def get_model_provider_variable_mapping_large():
        mapping = {}
        for i in range(1000):
            mapping[f"Provider{i}"] = f"PROVIDER{i}_API_KEY"
        return mapping
    # Patch the function locally
    global get_model_provider_variable_mapping
    old_mapping = get_model_provider_variable_mapping
    get_model_provider_variable_mapping = get_model_provider_variable_mapping_large

    # Test a few known and unknown variable names
    codeflash_output = get_provider_from_variable_name("PROVIDER0_API_KEY")
    codeflash_output = get_provider_from_variable_name("PROVIDER999_API_KEY")
    codeflash_output = get_provider_from_variable_name("PROVIDER500_API_KEY")
    codeflash_output = get_provider_from_variable_name("PROVIDER1000_API_KEY")
    codeflash_output = get_provider_from_variable_name("PROVIDER_API_KEY")

    # Test performance: all should be found correctly
    for i in range(0, 1000, 100):  # 0, 100, ..., 900
        var_name = f"PROVIDER{i}_API_KEY"
        provider = f"Provider{i}"
        codeflash_output = get_provider_from_variable_name(var_name)

    # Restore original mapping
    get_model_provider_variable_mapping = old_mapping

def test_large_scale_collision():
    # Create a mapping where many providers share the same variable name
    def get_model_provider_variable_mapping_collision():
        return {f"Provider{i}": "SHARED_API_KEY" for i in range(100)}
    global get_model_provider_variable_mapping
    old_mapping = get_model_provider_variable_mapping
    get_model_provider_variable_mapping = get_model_provider_variable_mapping_collision

    # Should return one of the providers (first found)
    codeflash_output = get_provider_from_variable_name("SHARED_API_KEY"); result = codeflash_output

    # Should return None for unknown variable name
    codeflash_output = get_provider_from_variable_name("NOT_SHARED_API_KEY")

    # Restore original mapping
    get_model_provider_variable_mapping = old_mapping

def test_large_scale_empty_mapping():
    # Test with an empty mapping
    def get_model_provider_variable_mapping_empty():
        return {}
    global get_model_provider_variable_mapping
    old_mapping = get_model_provider_variable_mapping
    get_model_provider_variable_mapping = get_model_provider_variable_mapping_empty

    # Should always return None
    codeflash_output = get_provider_from_variable_name("ANY_API_KEY")

    # Restore original mapping
    get_model_provider_variable_mapping = old_mapping
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import pytest
from langflow.api.v1.models import get_provider_from_variable_name


# --- function to test ---
# Simulate the imported function and its dependency for testing purposes.
# In real usage, get_model_provider_variable_mapping would be imported from lfx.base.models.unified_models
def get_model_provider_variable_mapping():
    # Example mapping for test purposes
    return {
        "OpenAI": "OPENAI_API_KEY",
        "Anthropic": "ANTHROPIC_API_KEY",
        "Google": "GOOGLE_API_KEY",
        "Cohere": "COHERE_API_KEY",
        "Azure": "AZURE_OPENAI_API_KEY",
        "AWS": "AWS_ACCESS_KEY_ID",
        "Custom": "CUSTOM_PROVIDER_KEY",
        "Empty": "",
        "Lowercase": "lowercase_api_key"
    }
from langflow.api.v1.models import get_provider_from_variable_name

# --- unit tests ---

# Basic Test Cases

def test_basic_known_variable_names():
    # Test with known variable names
    codeflash_output = get_provider_from_variable_name("OPENAI_API_KEY")
    codeflash_output = get_provider_from_variable_name("ANTHROPIC_API_KEY")
    codeflash_output = get_provider_from_variable_name("GOOGLE_API_KEY")
    codeflash_output = get_provider_from_variable_name("COHERE_API_KEY")
    codeflash_output = get_provider_from_variable_name("AZURE_OPENAI_API_KEY")
    codeflash_output = get_provider_from_variable_name("AWS_ACCESS_KEY_ID")
    codeflash_output = get_provider_from_variable_name("CUSTOM_PROVIDER_KEY")
    codeflash_output = get_provider_from_variable_name("lowercase_api_key")

def test_basic_returns_none_for_unknown_variable():
    # Test with variable names not in the mapping
    codeflash_output = get_provider_from_variable_name("NOT_A_PROVIDER_KEY")
    codeflash_output = get_provider_from_variable_name("OPENAI_SECRET_KEY")
    codeflash_output = get_provider_from_variable_name("ANTHROPIC_SECRET")

def test_basic_empty_string_variable_name():
    # Test with empty string as variable name
    codeflash_output = get_provider_from_variable_name("")  # Because mapping has "Empty": ""

# Edge Test Cases

def test_edge_case_case_sensitivity():
    # Test that function is case sensitive
    codeflash_output = get_provider_from_variable_name("openai_api_key")  # Should not match "OPENAI_API_KEY"
    codeflash_output = get_provider_from_variable_name("OPENAI_api_KEY")
    codeflash_output = get_provider_from_variable_name("OPENAI_API_KEY ")  # Trailing space

def test_edge_case_leading_trailing_whitespace():
    # Test with leading/trailing whitespace
    codeflash_output = get_provider_from_variable_name(" OPENAI_API_KEY")
    codeflash_output = get_provider_from_variable_name("OPENAI_API_KEY ")
    codeflash_output = get_provider_from_variable_name("  ")

def test_edge_case_special_characters():
    # Test with special characters
    codeflash_output = get_provider_from_variable_name("@OPENAI_API_KEY!")
    codeflash_output = get_provider_from_variable_name("COHERE-API-KEY")



def test_edge_case_duplicate_variable_names(monkeypatch):
    # Test that if two providers have the same variable name, the first one in the mapping is returned
    def fake_mapping():
        return {
            "ProviderA": "DUPLICATE_KEY",
            "ProviderB": "DUPLICATE_KEY",
            "ProviderC": "UNIQUE_KEY"
        }
    monkeypatch.setattr(__name__ + ".get_model_provider_variable_mapping", fake_mapping)
    codeflash_output = get_provider_from_variable_name("DUPLICATE_KEY")
    codeflash_output = get_provider_from_variable_name("UNIQUE_KEY")
    codeflash_output = get_provider_from_variable_name("NOT_FOUND")

def test_edge_case_empty_mapping(monkeypatch):
    # Test when the mapping is empty
    def fake_mapping():
        return {}
    monkeypatch.setattr(__name__ + ".get_model_provider_variable_mapping", fake_mapping)
    codeflash_output = get_provider_from_variable_name("ANY_KEY")
    codeflash_output = get_provider_from_variable_name("")

def test_edge_case_mapping_with_none_values(monkeypatch):
    # Test when mapping contains None as a value
    def fake_mapping():
        return {
            "ProviderA": None,
            "ProviderB": "B_KEY"
        }
    monkeypatch.setattr(__name__ + ".get_model_provider_variable_mapping", fake_mapping)
    codeflash_output = get_provider_from_variable_name(None)  # TypeError for input None, but here it's value in mapping
    codeflash_output = get_provider_from_variable_name("B_KEY")
    codeflash_output = get_provider_from_variable_name("ProviderA")

def test_edge_case_mapping_with_non_string_keys_and_values(monkeypatch):
    # Test when mapping contains non-string keys/values (should still match by ==)
    def fake_mapping():
        return {
            123: "NUMERIC_KEY",
            "ProviderB": 456,
            "ProviderC": "C_KEY"
        }
    monkeypatch.setattr(__name__ + ".get_model_provider_variable_mapping", fake_mapping)
    codeflash_output = get_provider_from_variable_name("NUMERIC_KEY")
    codeflash_output = get_provider_from_variable_name(456)
    codeflash_output = get_provider_from_variable_name("C_KEY")
    codeflash_output = get_provider_from_variable_name("NOT_FOUND")

# Large Scale Test Cases

def test_large_scale_many_providers(monkeypatch):
    # Test with a large mapping (1000 entries)
    large_mapping = {f"Provider{i}": f"PROVIDER_{i}_API_KEY" for i in range(1000)}
    monkeypatch.setattr(__name__ + ".get_model_provider_variable_mapping", lambda: large_mapping)
    # Test a few random entries
    codeflash_output = get_provider_from_variable_name("PROVIDER_0_API_KEY")
    codeflash_output = get_provider_from_variable_name("PROVIDER_999_API_KEY")
    codeflash_output = get_provider_from_variable_name("PROVIDER_500_API_KEY")
    # Test a non-existent key
    codeflash_output = get_provider_from_variable_name("PROVIDER_1000_API_KEY")

def test_large_scale_performance(monkeypatch):
    # Test that performance is reasonable for large mapping (not a strict timing test)
    large_mapping = {f"Provider{i}": f"PROVIDER_{i}_API_KEY" for i in range(1000)}
    monkeypatch.setattr(__name__ + ".get_model_provider_variable_mapping", lambda: large_mapping)
    # Check that all mappings return the correct provider
    for i in range(0, 1000, 100):  # Check every 100th to avoid long test
        key = f"PROVIDER_{i}_API_KEY"
        expected = f"Provider{i}"
        codeflash_output = get_provider_from_variable_name(key)
    # Check a few that should not be found
    codeflash_output = get_provider_from_variable_name("NOT_A_VALID_KEY")

def test_large_scale_duplicate_values(monkeypatch):
    # Test with many providers sharing the same variable name
    mapping = {f"Provider{i}": "SHARED_KEY" for i in range(100)}
    monkeypatch.setattr(__name__ + ".get_model_provider_variable_mapping", lambda: mapping)
    # Should always return the first provider in the mapping
    codeflash_output = get_provider_from_variable_name("SHARED_KEY"); result = codeflash_output
# 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-pr10565-2025-12-08T21.08.36 and push.

[coderabbitai]

Important

Review skipped

Bot user detected.

To trigger a single review, invoke the @coderabbitai review command.

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

---

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[codecov]

Codecov Report

❌ Patch coverage is 31.66227% with 259 lines in your changes missing coverage. Please review.
✅ Project coverage is 32.62%. Comparing base (101cbd0) to head (2d1c114).
⚠️ Report is 292 commits behind head on main.

Files with missing lines	Patch %	Lines
src/backend/base/langflow/api/v1/models.py	29.39%	221 Missing ⚠️
src/backend/base/langflow/api/v1/variable.py	33.33%	36 Missing ⚠️
src/backend/base/langflow/api/v1/model_options.py	80.00%	2 Missing ⚠️

❌ Your patch status has failed because the patch coverage (31.66%) is below the target coverage (40.00%). You can increase the patch coverage or adjust the target coverage.
❌ Your project status has failed because the head coverage (39.26%) is below the target coverage (60.00%). You can increase the head coverage or adjust the target coverage.

Additional details and impacted files

@@            Coverage Diff             @@
##             main   #10937      +/-   ##
==========================================
+ Coverage   32.60%   32.62%   +0.01%     
==========================================
  Files        1372     1387      +15     
  Lines       63563    65021    +1458     
  Branches     9388     9643     +255     
==========================================
+ Hits        20725    21210     +485     
- Misses      41795    42720     +925     
- Partials     1043     1091      +48     

Flag	Coverage Δ
backend	51.32% <31.66%> (-0.35%)	⬇️
lfx	39.26% <ø> (-0.77%)	⬇️

Flags with carried forward coverage won't be shown. Click here to find out more.

Files with missing lines	Coverage Δ
src/backend/base/langflow/api/router.py	100.00% <100.00%> (ø)
src/backend/base/langflow/inputs/inputs.py	0.00% <ø> (ø)
...angflow/services/database/models/variable/model.py	100.00% <ø> (ø)
...rc/backend/base/langflow/services/variable/base.py	100.00% <ø> (ø)
...kend/base/langflow/services/variable/kubernetes.py	0.00% <ø> (ø)
...backend/base/langflow/services/variable/service.py	87.97% <ø> (+0.26%)	⬆️
...es/GenericNode/components/NodeInputField/index.tsx	0.00% <ø> (ø)
...nents/common/modelProviderCountComponent/index.tsx	95.00% <ø> (ø)
...d/src/components/core/appHeaderComponent/index.tsx	0.00% <ø> (ø)
...onents/inputComponent/components/popover/index.tsx	11.94% <ø> (-0.37%)	⬇️
... and 36 more

... and 27 files with indirect coverage changes

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[ogabrielluiz]

Closing automated codeflash PR.