⚡️ Speed up function convert_llm by 163% in PR #8930 (release-1.5.0)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #8930

If you approve this dependent PR, these changes will be merged into the original PR branch release-1.5.0.

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

---

📄 163% (1.63x) speedup for convert_llm in src/backend/base/langflow/base/agents/crewai/crew.py

⏱️ Runtime : 4.74 milliseconds → 1.80 milliseconds (best of 92 runs)

📝 Explanation and details

Here is a rewritten, optimized version of your program, focusing on significant hot spots (from the line profiler) and leveraging locality, reduced allocations, and fast Python idioms. The main bottleneck is _find_api_key, particularly attribute access and lower-casing/search, and the dict filtering at the bottom of convert_llm.

Key changes for speed.

• _find_api_key.
  • Use a cached set of lower patterns for fast in checks.
  • Scan attributes and look up only first string/SecretStr-valued matching attribute—stop early.
  • Use model.__dict__ where possible for speed, fallback to dir() only if needed, prefer vars(model) (which is essentially __dict__) for most models.
  • Minimize repeated operations inside loops.
• convert_llm.
  • Precompute the dict filter set and use list comprehensions (Py3.7+ dicts preserve order and are fast).
  • Inline all known one-time representatives outside repeated control flow.
  • Only get the dict once.

Summary of speed improvements:

• Use vars(model)/.__dict__ directly if available—faster than dir() and less work.
• Inline filter for key in attribute (avoiding unnecessary generator).
• Attribute access and string lowercasing only occur once per attribute.
• convert_llm dict filtering is now single-pass.
• Overall effect: Dramatically reduces function call count, attribute access, and per-item python overhead in both hot spots.

If you want even further micro-optimization for _find_api_key, you may also break on the first found attribute whose value is not None, rather than searching all attributes—but normally there is just one such key so this won't matter for correctness or speed.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import sys
import types
from typing import Any, Dict, Set

# imports
import pytest  # used for our unit tests
from langflow.base.agents.crewai.crew import convert_llm
# function to test
from pydantic import SecretStr

# --- End function definitions ---

# --- Begin test scaffolding ---

# Dummy CrewAI LLM class for testing (to avoid dependency on real crewai)
class DummyLLM:
    def __init__(self, model, api_key=None, api_base=None, **kwargs):
        self.model = model
        self.api_key = api_key
        self.api_base = api_base
        self.extra = kwargs

    def __eq__(self, other):
        if not isinstance(other, DummyLLM):
            return False
        return (
            self.model == other.model and
            self.api_key == other.api_key and
            self.api_base == other.api_base and
            self.extra == other.extra
        )

    def __repr__(self):
        return f"DummyLLM(model={self.model!r}, api_key={self.api_key!r}, api_base={self.api_base!r}, extra={self.extra!r})"

# Minimal mock for LangChain LLM-like objects
class MockLangChainLLM:
    def __init__(
        self,
        model_name=None,
        model=None,
        deployment_name=None,
        api_key=None,
        openai_api_key=None,
        token=None,
        azure_endpoint=None,
        get_lc_namespace=None,
        dict_values=None,
        **kwargs
    ):
        self.model_name = model_name
        self.model = model
        self.deployment_name = deployment_name
        self.api_key = api_key
        self.openai_api_key = openai_api_key
        self.token = token
        self.azure_endpoint = azure_endpoint
        self._type = kwargs.get("_type", None)
        self.azure_deployment = kwargs.get("azure_deployment", None)
        self.extra_attrs = kwargs
        self._dict_values = dict_values or {}

        # get_lc_namespace is a function returning a list
        if get_lc_namespace is not None:
            self.get_lc_namespace = get_lc_namespace
        else:
            # Default to ["langchain_openai"]
            self.get_lc_namespace = lambda: ["langchain_openai"]

    def dict(self):
        # Return the dict representation, plus any extra attributes
        base = dict(self._dict_values)
        # Add any extra attributes not in dict_values
        for k, v in self.extra_attrs.items():
            if k not in base:
                base[k] = v
        return base

# --- End test scaffolding ---

# --- Begin unit tests ---

# 1. BASIC TEST CASES

def test_returns_none_for_none_input():
    """Should return None if llm is None."""
    codeflash_output = convert_llm(None)

def test_returns_none_for_falsey_input():
    """Should return None if llm is False."""
    codeflash_output = convert_llm(False)


def test_model_name_priority():
    """Should use model_name if present and not None/empty."""
    llm = MockLangChainLLM(
        model_name="gpt-3.5",
        get_lc_namespace=lambda: ["langchain_openai"],
        dict_values={"temperature": 0.7, "foo": "bar"}
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_model_fallback_to_model():
    """Should use model if model_name is missing."""
    llm = MockLangChainLLM(
        model="llama-2",
        get_lc_namespace=lambda: ["langchain_huggingface"],
        dict_values={"temperature": 0.1}
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_model_fallback_to_deployment_name():
    """Should use deployment_name if model_name and model are missing."""
    llm = MockLangChainLLM(
        deployment_name="azure-deploy",
        azure_endpoint="https://example.azure.com",
        get_lc_namespace=lambda: ["langchain_openai"],
        dict_values={"max_tokens": 100}
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_api_key_detection_string():
    """Should extract api_key if present as string."""
    llm = MockLangChainLLM(
        model_name="gpt",
        api_key="sk-123",
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_api_key_detection_secretstr():
    """Should extract api_key if present as SecretStr."""
    llm = MockLangChainLLM(
        model_name="gpt",
        api_key=SecretStr("sk-secret"),
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_api_key_detection_token():
    """Should extract token if present."""
    llm = MockLangChainLLM(
        model_name="gpt",
        token="tok-abc",
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_api_key_detection_openai_api_key():
    """Should extract openai_api_key if present."""
    llm = MockLangChainLLM(
        model_name="gpt",
        openai_api_key="sk-openai",
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_extra_fields_are_passed():
    """Should pass extra fields from dict() to DummyLLM except excluded_keys."""
    llm = MockLangChainLLM(
        model_name="foo",
        get_lc_namespace=lambda: ["langchain_openai"],
        dict_values={"temperature": 0.2, "model_name": "should_be_excluded", "foo": "bar"}
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

# 2. EDGE TEST CASES

def test_missing_all_model_names_raises():
    """Should raise ValueError if no model_name/model/deployment_name is present."""
    llm = MockLangChainLLM(
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    with pytest.raises(ValueError, match="Could not find model name in the LLM object"):
        convert_llm(llm)

def test_provider_prefix_removal():
    """Should remove langchain_ prefix from provider when constructing model name."""
    llm = MockLangChainLLM(
        model_name="gpt",
        get_lc_namespace=lambda: ["langchain_huggingface"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_azure_endpoint_sets_api_base_and_model_name():
    """Should set api_base and prefix model with 'azure/' if azure_endpoint is present."""
    llm = MockLangChainLLM(
        model_name="gpt-4",
        azure_endpoint="https://azure.example.com",
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_excluded_keys_removal():
    """Should exclude keys in excluded_keys from dict() output."""
    llm = MockLangChainLLM(
        model_name="gpt-4",
        get_lc_namespace=lambda: ["langchain_openai"],
        dict_values={"model": "should_be_excluded", "foo": "bar", "baz": 1}
    )
    codeflash_output = convert_llm(llm, excluded_keys={"model", "baz"}); result = codeflash_output

def test_empty_dict_values():
    """Should handle when dict() returns empty dict."""
    llm = MockLangChainLLM(
        model_name="gpt-4",
        get_lc_namespace=lambda: ["langchain_openai"],
        dict_values={}
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_api_key_not_found_returns_none():
    """Should set api_key to None if not found."""
    llm = MockLangChainLLM(
        model_name="gpt-4",
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_dict_with_overlapping_excluded_keys():
    """Should not include any excluded keys even if present in dict()."""
    llm = MockLangChainLLM(
        model_name="gpt-4",
        get_lc_namespace=lambda: ["langchain_openai"],
        dict_values={"model": "foo", "model_name": "bar", "api_key": "should_not_be_included", "foo": "baz"}
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_non_string_api_key_ignored():
    """Should not extract api_key if attribute is not string or SecretStr."""
    class WeirdLLM(MockLangChainLLM):
        def __init__(self):
            super().__init__(model_name="gpt", get_lc_namespace=lambda: ["langchain_openai"])
            self.api_key = 12345  # Not a string or SecretStr

    llm = WeirdLLM()
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_model_name_empty_string():
    """Should fall back to model if model_name is empty string."""
    llm = MockLangChainLLM(
        model_name="",
        model="actual-model",
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_model_name_none_and_model_none_and_deployment_name_present():
    """Should use deployment_name if model_name and model are None."""
    llm = MockLangChainLLM(
        model_name=None,
        model=None,
        deployment_name="deploy-x",
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

# 3. LARGE SCALE TEST CASES

def test_large_number_of_extra_fields():
    """Should handle LLM with many extra fields efficiently and correctly."""
    extra_fields = {f"field_{i}": i for i in range(500)}
    llm = MockLangChainLLM(
        model_name="big-model",
        get_lc_namespace=lambda: ["langchain_openai"],
        dict_values=extra_fields
    )
    codeflash_output = convert_llm(llm); result = codeflash_output
    # All fields except excluded_keys should be present
    for k in extra_fields:
        if k not in {"model", "model_name", "_type", "api_key", "azure_deployment"}:
            pass

def test_large_scale_api_key_search():
    """Should efficiently search for API key among many attributes."""
    # Add 500 unrelated attributes, one of which is 'my_token'
    attrs = {f"attr_{i}": i for i in range(499)}
    attrs["my_token"] = "token-xyz"
    llm = MockLangChainLLM(
        model_name="gpt-4",
        get_lc_namespace=lambda: ["langchain_openai"],
        dict_values={},
        **attrs
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_large_scale_excluded_keys():
    """Should efficiently exclude a large set of keys."""
    all_fields = {f"field_{i}": i for i in range(1000)}
    excluded = {f"field_{i}" for i in range(1000) if i % 2 == 0}  # Exclude even fields
    llm = MockLangChainLLM(
        model_name="gpt-large",
        get_lc_namespace=lambda: ["langchain_openai"],
        dict_values=all_fields
    )
    codeflash_output = convert_llm(llm, excluded_keys=excluded); result = codeflash_output
    # Only odd fields should be present
    for i in range(1000):
        k = f"field_{i}"
        if i % 2 == 0:
            pass
        else:
            pass

def test_performance_with_many_calls(monkeypatch):
    """Should not leak memory or slow down with many calls."""
    # This is a smoke test for repeated conversion
    llm = MockLangChainLLM(
        model_name="gpt-fast",
        get_lc_namespace=lambda: ["langchain_openai"],
        dict_values={"foo": "bar"}
    )
    for _ in range(100):
        codeflash_output = convert_llm(llm); 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.

import sys
import types
from typing import Any

# imports
import pytest
from langflow.base.agents.crewai.crew import convert_llm
from pydantic import SecretStr

# --- Mock CrewAI LLM class for testing ---

class DummyLLM:
    """A dummy LangChain LLM-like object for testing."""
    def __init__(
        self,
        model_name=None,
        model=None,
        deployment_name=None,
        api_key=None,
        azure_endpoint=None,
        extra_attrs=None,
        secret_token=None,
        get_lc_namespace=None,
        dict_attrs=None,
    ):
        self.model_name = model_name
        self.model = model
        self.deployment_name = deployment_name
        self.api_key = api_key
        self.azure_endpoint = azure_endpoint
        self.secret_token = secret_token
        self.extra_attrs = extra_attrs or {}
        self._dict_attrs = dict_attrs or {}
        self._get_lc_namespace = get_lc_namespace or (lambda: ["langchain_dummy"])

    def get_lc_namespace(self):
        return self._get_lc_namespace()

    def dict(self):
        # Merge all fields for dict representation
        d = {
            "model_name": self.model_name,
            "model": self.model,
            "deployment_name": self.deployment_name,
            "api_key": self.api_key,
            "azure_endpoint": self.azure_endpoint,
            "secret_token": self.secret_token,
        }
        d.update(self.extra_attrs)
        d.update(self._dict_attrs)
        return {k: v for k, v in d.items() if v is not None}


class DummyCrewAILLM:
    def __init__(self, model, api_key=None, api_base=None, **kwargs):
        self.model = model
        self.api_key = api_key
        self.api_base = api_base
        self.extra = kwargs

    def __eq__(self, other):
        if not isinstance(other, DummyCrewAILLM):
            return False
        return (
            self.model == other.model and
            self.api_key == other.api_key and
            self.api_base == other.api_base and
            self.extra == other.extra
        )

    def __repr__(self):
        return f"DummyCrewAILLM(model={self.model!r}, api_key={self.api_key!r}, api_base={self.api_base!r}, extra={self.extra!r})"

# Patch sys.modules so that 'from crewai import LLM' imports our dummy
crewai_mod = types.ModuleType("crewai")
crewai_mod.LLM = DummyCrewAILLM
sys.modules["crewai"] = crewai_mod

# --- Unit Tests ---

# 1. Basic Test Cases

def test_convert_llm_basic_model_name():
    """Test normal conversion with model_name and api_key."""
    llm = DummyLLM(
        model_name="gpt-4",
        api_key="testkey123",
        extra_attrs={"temperature": 0.7},
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_convert_llm_basic_model():
    """Test conversion with model attribute instead of model_name."""
    llm = DummyLLM(
        model="babbage",
        api_key="abcde",
        extra_attrs={"max_tokens": 512},
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_convert_llm_basic_deployment_name():
    """Test conversion with deployment_name attribute."""
    llm = DummyLLM(
        deployment_name="deployment-42",
        api_key="deploykey",
        get_lc_namespace=lambda: ["langchain_azure"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_convert_llm_returns_original_if_crewai_llm():
    """If passed a CrewAI LLM object, should return it unchanged."""
    original = DummyCrewAILLM(model="foo", api_key="bar", api_base="baz")
    codeflash_output = convert_llm(original); result = codeflash_output

def test_convert_llm_with_secretstr_api_key():
    """Test conversion with SecretStr api_key."""
    secret = SecretStr("supersecret")
    llm = DummyLLM(
        model_name="gpt-secret",
        api_key=secret,
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_convert_llm_with_token_in_name():
    """Test conversion where API token is stored in an attribute with 'token' in name."""
    class TokenLLM(DummyLLM):
        def __init__(self, **kwargs):
            super().__init__(**kwargs)
            self.user_token = "tok123"
    llm = TokenLLM(
        model_name="gpt-token",
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_convert_llm_with_azure_endpoint():
    """Test conversion with azure_endpoint attribute."""
    llm = DummyLLM(
        deployment_name="deploy-azure",
        api_key="azkey",
        azure_endpoint="https://azure.openai.com",
        get_lc_namespace=lambda: ["langchain_azure"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

# 2. Edge Test Cases

def test_convert_llm_none_input():
    """Passing None should return None."""
    codeflash_output = convert_llm(None)

def test_convert_llm_empty_object():
    """Passing an object without model_name/model/deployment_name should raise ValueError."""
    llm = DummyLLM()
    with pytest.raises(ValueError) as excinfo:
        convert_llm(llm)

def test_convert_llm_missing_namespace():
    """If get_lc_namespace returns an empty list, should raise IndexError."""
    llm = DummyLLM(
        model_name="gpt-edge",
        get_lc_namespace=lambda: []
    )
    with pytest.raises(IndexError):
        convert_llm(llm)

def test_convert_llm_excluded_keys_removal():
    """Test that excluded_keys are not present in the extra dict."""
    llm = DummyLLM(
        model_name="gpt-4",
        api_key="shouldnotappear",
        extra_attrs={"foo": "bar", "model": "should_exclude"},
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output


def test_convert_llm_with_non_string_api_key():
    """Test that non-string, non-SecretStr api_key is ignored."""
    llm = DummyLLM(
        model_name="gpt-4",
        api_key=12345,  # not a string or SecretStr
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_convert_llm_with_multiple_key_patterns():
    """Test that the first matching key pattern is picked up."""
    class MultiKeyLLM(DummyLLM):
        def __init__(self, **kwargs):
            super().__init__(**kwargs)
            self.first_token = "token1"
            self.second_key = "key2"
    llm = MultiKeyLLM(
        model_name="gpt-multi",
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_convert_llm_with_dict_attrs():
    """Test that dict() values are included in extra if not excluded."""
    llm = DummyLLM(
        model_name="gpt-dict",
        api_key="dictkey",
        dict_attrs={"foo": 1, "bar": 2, "model": "should_exclude"},
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output

def test_convert_llm_importerror_message(monkeypatch):
    """Test that ImportError is raised with the correct message if crewai is not installed."""
    # Remove crewai from sys.modules for this test
    monkeypatch.setitem(sys.modules, "crewai", None)
    llm = DummyLLM(model_name="gpt-4", get_lc_namespace=lambda: ["langchain_openai"])
    # Remove our dummy module
    sys.modules.pop("crewai", None)
    with pytest.raises(ImportError) as excinfo:
        convert_llm(llm)
    # Restore dummy for other tests
    sys.modules["crewai"] = crewai_mod

# 3. Large Scale Test Cases

def test_convert_llm_large_number_of_attrs():
    """Test conversion with many extra attributes."""
    # 500 extra attributes
    extra = {f"attr{i}": i for i in range(500)}
    llm = DummyLLM(
        model_name="gpt-large",
        api_key="largekey",
        extra_attrs=extra,
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output
    for i in range(500):
        pass

def test_convert_llm_large_dict_attrs():
    """Test conversion with many dict() attributes, ensuring exclusion works."""
    dict_attrs = {f"field{i}": i for i in range(500)}
    dict_attrs["model"] = "should_exclude"
    dict_attrs["api_key"] = "should_exclude"
    llm = DummyLLM(
        model_name="gpt-large-dict",
        api_key="dictkey",
        dict_attrs=dict_attrs,
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output
    for i in range(500):
        pass

def test_convert_llm_large_scale_performance():
    """Test conversion does not error with 999 attributes."""
    attrs = {f"x{i}": i for i in range(999)}
    llm = DummyLLM(
        model_name="gpt-max",
        api_key="maxkey",
        extra_attrs=attrs,
        get_lc_namespace=lambda: ["langchain_openai"]
    )
    codeflash_output = convert_llm(llm); result = codeflash_output
    # Spot check a few attributes
    for i in [0, 100, 500, 998]:
        pass

To edit these changes git checkout codeflash/optimize-pr8930-2025-07-08T12.55.56 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.

---

🪧 Tips

Chat

There are 3 ways to chat with CodeRabbit:

• Review comments: Directly reply to a review comment made by CodeRabbit. Example:
  • I pushed a fix in commit <commit_id>, please review it.
  • Explain this complex logic.
  • Open a follow-up GitHub issue for this discussion.
• Files and specific lines of code (under the "Files changed" tab): Tag @coderabbitai in a new review comment at the desired location with your query. Examples:
  • @coderabbitai explain this code block.
  • @coderabbitai modularize this function.
• PR comments: Tag @coderabbitai in a new PR comment to ask questions about the PR branch. For the best results, please provide a very specific query, as very limited context is provided in this mode. Examples:
  • @coderabbitai gather interesting stats about this repository and render them as a table. Additionally, render a pie chart showing the language distribution in the codebase.
  • @coderabbitai read src/utils.ts and explain its main purpose.
  • @coderabbitai read the files in the src/scheduler package and generate a class diagram using mermaid and a README in the markdown format.
  • @coderabbitai help me debug CodeRabbit configuration file.

Support

Need help? Join our Discord community for assistance with any issues or questions.

Note: Be mindful of the bot's finite context window. It's strongly recommended to break down tasks such as reading entire modules into smaller chunks. For a focused discussion, use review comments to chat about specific files and their changes, instead of using the PR comments.

CodeRabbit Commands (Invoked using PR comments)

• @coderabbitai pause to pause the reviews on a PR.
• @coderabbitai resume to resume the paused reviews.
• @coderabbitai review to trigger an incremental review. This is useful when automatic reviews are disabled for the repository.
• @coderabbitai full review to do a full review from scratch and review all the files again.
• @coderabbitai summary to regenerate the summary of the PR.
• @coderabbitai generate sequence diagram to generate a sequence diagram of the changes in this PR.
• @coderabbitai resolve resolve all the CodeRabbit review comments.
• @coderabbitai configuration to show the current CodeRabbit configuration for the repository.
• @coderabbitai help to get help.

Other keywords and placeholders

• Add @coderabbitai ignore anywhere in the PR description to prevent this PR from being reviewed.
• Add @coderabbitai summary to generate the high-level summary at a specific location in the PR description.
• Add @coderabbitai anywhere in the PR title to generate the title automatically.

Documentation and Community

• Visit our Documentation for detailed information on how to use CodeRabbit.
• Join our Discord Community to get help, request features, and share feedback.
• Follow us on X/Twitter for updates and announcements.