⚡️ Speed up function config_contains_sse_url by 21% in PR #9539 (docs-openai-api-endpoint)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #9539

If you approve this dependent PR, these changes will be merged into the original PR branch docs-openai-api-endpoint.

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

---

📄 21% (0.21x) speedup for config_contains_sse_url in langflow/api/v1/mcp_projects.py

⏱️ Runtime : 741 microseconds → 613 microseconds (best of 51 runs)

📝 Explanation and details

The optimization removes the default empty list [] from server_config.get("args", []) and changes it to server_config.get("args"). This small change eliminates unnecessary list object creation when the "args" key is missing from server configurations.

Key optimization: Instead of creating a new empty list every time a server config lacks an "args" key, the code now gets None and relies on the existing if args and args[-1] == sse_url: check to handle both missing keys and empty lists correctly.

Why this is faster: In Python, creating list objects has overhead - even empty lists require memory allocation and object initialization. The line profiler shows this optimization saves ~140 microseconds (4.7% improvement) on the args = server_config.get("args") line specifically. When this line executes 6,574 times in the profiled run, these small savings compound to a meaningful 20% overall speedup.

Test case performance: This optimization is particularly effective for configurations with many servers that lack "args" keys, as shown in test cases like test_large_number_of_servers_some_with_empty_args() where half the servers have missing args. The more servers without args keys, the more list creations are avoided.

The behavior remains identical since None and args[-1] == sse_url still evaluates to False just like [] and args[-1] == sse_url would.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Any

# imports
import pytest  # used for our unit tests
from langflow.api.v1.mcp_projects import config_contains_sse_url


class DummyLogger:
    def debug(self, msg, *args, **kwargs):
        pass

# Dummy logger to avoid side effects during testing
logger = DummyLogger()
from langflow.api.v1.mcp_projects import config_contains_sse_url

# ------------------- UNIT TESTS -------------------

# 1. BASIC TEST CASES

def test_empty_config_returns_false():
    # No mcpServers key
    codeflash_output = config_contains_sse_url({}, "http://foo")

def test_empty_mcpservers_returns_false():
    # mcpServers is empty dict
    config = {"mcpServers": {}}
    codeflash_output = config_contains_sse_url(config, "http://foo")

def test_single_server_matching_url():
    # Single server, args ends with matching sse_url
    config = {"mcpServers": {"server1": {"args": ["--foo", "http://bar"]}}}
    codeflash_output = config_contains_sse_url(config, "http://bar")

def test_single_server_non_matching_url():
    # Single server, args ends with non-matching sse_url
    config = {"mcpServers": {"server1": {"args": ["--foo", "http://bar"]}}}
    codeflash_output = config_contains_sse_url(config, "http://baz")

def test_multiple_servers_one_matches():
    # Multiple servers, one matches
    config = {
        "mcpServers": {
            "server1": {"args": ["--foo", "http://bar"]},
            "server2": {"args": ["--foo", "http://baz"]},
        }
    }
    codeflash_output = config_contains_sse_url(config, "http://baz")

def test_multiple_servers_none_match():
    # Multiple servers, none matches
    config = {
        "mcpServers": {
            "server1": {"args": ["--foo", "http://bar"]},
            "server2": {"args": ["--foo", "http://baz"]},
        }
    }
    codeflash_output = config_contains_sse_url(config, "http://qux")

def test_args_is_empty_list():
    # args is empty list
    config = {"mcpServers": {"server1": {"args": []}}}
    codeflash_output = config_contains_sse_url(config, "http://foo")

def test_args_missing_key():
    # args key is missing
    config = {"mcpServers": {"server1": {}}}
    codeflash_output = config_contains_sse_url(config, "http://foo")

def test_args_single_element_matching():
    # args is a single-element list, matches
    config = {"mcpServers": {"server1": {"args": ["http://foo"]}}}
    codeflash_output = config_contains_sse_url(config, "http://foo")

def test_args_single_element_non_matching():
    # args is a single-element list, does not match
    config = {"mcpServers": {"server1": {"args": ["http://bar"]}}}
    codeflash_output = config_contains_sse_url(config, "http://foo")

# 2. EDGE TEST CASES

def test_sse_url_is_empty_string():
    # sse_url is empty string, should only match if last arg is also ""
    config = {"mcpServers": {"server1": {"args": ["foo", ""]}}}
    codeflash_output = config_contains_sse_url(config, "")
    config = {"mcpServers": {"server1": {"args": ["foo", "bar"]}}}
    codeflash_output = config_contains_sse_url(config, "")

def test_args_contains_none():
    # args contains None as last element
    config = {"mcpServers": {"server1": {"args": ["foo", None]}}}
    codeflash_output = config_contains_sse_url(config, None)
    codeflash_output = config_contains_sse_url(config, "foo")

def test_args_is_not_a_list():
    # args is not a list (should be robust)
    config = {"mcpServers": {"server1": {"args": "notalist"}}}
    # Should treat as not a list, so .get("args", []) will be a string, so args[-1] == sse_url works for string
    # The last char of "notalist" is 't'
    codeflash_output = config_contains_sse_url(config, "t")
    codeflash_output = config_contains_sse_url(config, "notalist")


def test_mcpservers_key_is_none():
    # mcpServers key is None
    config = {None: {"server1": {"args": ["foo", "bar"]}}}
    codeflash_output = config_contains_sse_url(config, "bar")


def test_server_config_is_not_a_dict():
    # server config is not a dict
    config = {"mcpServers": {"server1": "notadict"}}
    # .get("args", []) will fail, so should raise AttributeError
    with pytest.raises(AttributeError):
        config_contains_sse_url(config, "foo")



def test_server_name_is_empty_string():
    # server name is empty string
    config = {"mcpServers": {"": {"args": ["foo", "bar"]}}}
    codeflash_output = config_contains_sse_url(config, "bar")

def test_server_name_is_none():
    # server name is None
    config = {"mcpServers": {None: {"args": ["foo", "bar"]}}}
    codeflash_output = config_contains_sse_url(config, "bar")

def test_args_has_multiple_identical_endings():
    # args ends with multiple identical sse_urls, only last should be checked
    config = {"mcpServers": {"server1": {"args": ["foo", "http://foo", "http://foo"]}}}
    codeflash_output = config_contains_sse_url(config, "http://foo")

def test_args_has_multiple_possible_matches_but_only_last_matters():
    # args has matching sse_url not at the end
    config = {"mcpServers": {"server1": {"args": ["http://foo", "http://bar"]}}}
    codeflash_output = config_contains_sse_url(config, "http://foo")
    codeflash_output = config_contains_sse_url(config, "http://bar")

def test_args_last_element_is_int():
    # args last element is int, sse_url is int
    config = {"mcpServers": {"server1": {"args": ["foo", 123]}}}
    codeflash_output = config_contains_sse_url(config, 123)
    codeflash_output = config_contains_sse_url(config, "123")

# 3. LARGE SCALE TEST CASES

def test_large_number_of_servers_none_match():
    # 1000 servers, none match
    config = {
        "mcpServers": {
            f"server{i}": {"args": [f"--foo{i}", f"http://bar{i}"]}
            for i in range(1000)
        }
    }
    codeflash_output = config_contains_sse_url(config, "http://notfound")

def test_large_number_of_servers_last_matches():
    # 1000 servers, last one matches
    config = {
        "mcpServers": {
            f"server{i}": {"args": [f"--foo{i}", f"http://bar{i}"]}
            for i in range(999)
        }
    }
    config["mcpServers"]["server999"] = {"args": ["--foo999", "http://target"]}
    codeflash_output = config_contains_sse_url(config, "http://target")

def test_large_args_list_in_server():
    # One server, args list has 999 elements, last matches
    args = [f"--arg{i}" for i in range(998)] + ["http://sse"]
    config = {"mcpServers": {"server1": {"args": args}}}
    codeflash_output = config_contains_sse_url(config, "http://sse")
    # Should not match for any other value
    codeflash_output = config_contains_sse_url(config, "http://notfound")

def test_large_args_list_in_multiple_servers():
    # 10 servers, each with large args list, only one matches
    config = {
        f"server{i}": {"args": [f"--arg{j}" for j in range(99)] + [f"http://foo{i}"]}
        for i in range(10)
    }
    config = {"mcpServers": config}
    codeflash_output = config_contains_sse_url(config, "http://foo5")
    codeflash_output = config_contains_sse_url(config, "http://foo10")

def test_large_config_with_missing_args_and_servers():
    # 500 servers, half with args, half without
    config = {
        "mcpServers": {
            f"server{i}": ({"args": [f"--foo{i}", f"http://bar{i}"]} if i % 2 == 0 else {})
            for i in range(500)
        }
    }
    # Should match for any even i
    codeflash_output = config_contains_sse_url(config, "http://bar10")
    # Should not match for odd i
    codeflash_output = config_contains_sse_url(config, "http://bar11")
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from types import SimpleNamespace

# imports
import pytest  # used for our unit tests
from langflow.api.v1.mcp_projects import config_contains_sse_url


# Dummy logger to satisfy import (since the real logger is not available)
class DummyLogger:
    def debug(self, *args, **kwargs):
        pass

logger = DummyLogger()
from langflow.api.v1.mcp_projects import config_contains_sse_url

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

def test_empty_config_returns_false():
    # No mcpServers key at all
    config = {}
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

def test_empty_mcpservers_returns_false():
    # mcpServers present but empty
    config = {"mcpServers": {}}
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

def test_single_server_with_matching_sse_url():
    # One server, args ends with the target URL
    config = {
        "mcpServers": {
            "server1": {
                "args": ["--foo", "--bar", "http://example.com/sse"]
            }
        }
    }
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

def test_single_server_with_non_matching_sse_url():
    # One server, args does not end with the target URL
    config = {
        "mcpServers": {
            "server1": {
                "args": ["--foo", "--bar", "http://not-the-url.com"]
            }
        }
    }
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

def test_multiple_servers_one_matches():
    # Multiple servers, only one matches
    config = {
        "mcpServers": {
            "server1": {"args": ["a", "b", "http://foo.com"]},
            "server2": {"args": ["x", "y", "http://example.com/sse"]},
            "server3": {"args": ["1", "2", "3"]}
        }
    }
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

def test_multiple_servers_none_match():
    # Multiple servers, none match
    config = {
        "mcpServers": {
            "server1": {"args": ["a", "b", "http://foo.com"]},
            "server2": {"args": ["x", "y", "http://bar.com"]},
            "server3": {"args": ["1", "2", "3"]}
        }
    }
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

def test_server_args_is_empty_list():
    # Server with empty args list
    config = {
        "mcpServers": {
            "server1": {"args": []}
        }
    }
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

def test_server_args_missing_key():
    # Server config missing 'args' key entirely
    config = {
        "mcpServers": {
            "server1": {}
        }
    }
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

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


def test_args_is_not_a_list():
    # Server config has 'args' as a string (wrong type)
    config = {
        "mcpServers": {
            "server1": {"args": "notalist"}
        }
    }
    # Should not crash, but since "notalist"[-1] != target, should be False
    # But since "notalist" is truthy and has last char != sse_url, should be False
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

def test_args_contains_multiple_matching_urls_only_last_matters():
    # Only the last arg is checked
    config = {
        "mcpServers": {
            "server1": {"args": ["http://example.com/sse", "http://example.com/sse", "not-this"]}
        }
    }
    # Last arg is not the target, so should be False
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

def test_last_arg_exact_match_required():
    # Last arg is a substring of sse_url, but not exact match
    config = {
        "mcpServers": {
            "server1": {"args": ["http://example.com/sse/extra"]}
        }
    }
    # Should require exact match, so should be False
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

def test_last_arg_exact_match_with_trailing_slash():
    # Last arg matches sse_url including trailing slash
    config = {
        "mcpServers": {
            "server1": {"args": ["http://example.com/sse/"]}
        }
    }
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse/")

def test_sse_url_is_empty_string():
    # sse_url is empty string, only matches if last arg is also empty string
    config = {
        "mcpServers": {
            "server1": {"args": ["a", ""]}
        }
    }
    codeflash_output = config_contains_sse_url(config, "")

def test_server_name_is_empty_string():
    # Server name is empty string
    config = {
        "mcpServers": {
            "": {"args": ["foo", "http://example.com/sse"]}
        }
    }
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

def test_args_list_with_single_element():
    # args is a single-element list
    config = {
        "mcpServers": {
            "server1": {"args": ["http://example.com/sse"]}
        }
    }
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

def test_args_list_with_non_string_elements():
    # args contains non-string elements
    config = {
        "mcpServers": {
            "server1": {"args": [42, "http://example.com/sse"]}
        }
    }
    # Last arg is string, but not matching
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

    config2 = {
        "mcpServers": {
            "server1": {"args": [42, "foo", 123]}
        }
    }
    # Last arg is int, not string, so should not match
    codeflash_output = config_contains_sse_url(config2, "123")


def test_config_data_is_none():
    # config_data is None
    with pytest.raises(AttributeError):
        config_contains_sse_url(None, "http://example.com/sse")

def test_config_data_is_not_a_dict():
    # config_data is a list
    with pytest.raises(AttributeError):
        config_contains_sse_url([], "http://example.com/sse")

def test_server_config_is_not_a_dict():
    # server config is a string
    config = {
        "mcpServers": {
            "server1": "notadict"
        }
    }
    # Should not crash, but will not have .get, so should raise AttributeError
    with pytest.raises(AttributeError):
        config_contains_sse_url(config, "http://example.com/sse")

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

def test_large_number_of_servers_none_match():
    # 999 servers, none match
    config = {
        "mcpServers": {
            f"server{i}": {"args": ["foo", f"url{i}"]} for i in range(999)
        }
    }
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

def test_large_number_of_servers_last_matches():
    # 999 servers, last one matches
    config = {
        "mcpServers": {
            f"server{i}": {"args": ["foo", f"url{i}"]} for i in range(998)
        }
    }
    config["mcpServers"]["server998"] = {"args": ["foo", "http://example.com/sse"]}
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

def test_large_args_list_last_matches():
    # One server, args list of length 999, last matches
    config = {
        "mcpServers": {
            "server1": {"args": [f"arg{i}" for i in range(998)] + ["http://example.com/sse"]}
        }
    }
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

def test_large_args_list_none_match():
    # One server, large args list, last does not match
    config = {
        "mcpServers": {
            "server1": {"args": [f"arg{i}" for i in range(999)]}
        }
    }
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

def test_large_number_of_servers_some_with_empty_args():
    # Many servers, some with empty args, one matches
    config = {
        "mcpServers": {
            f"server{i}": {"args": [] if i % 2 == 0 else ["foo", f"url{i}"]} for i in range(998)
        }
    }
    config["mcpServers"]["server998"] = {"args": ["foo", "http://example.com/sse"]}
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")

def test_large_number_of_servers_all_empty_args():
    # All servers have empty args
    config = {
        "mcpServers": {
            f"server{i}": {"args": []} for i in range(999)
        }
    }
    codeflash_output = config_contains_sse_url(config, "http://example.com/sse")
# 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-pr9539-2025-08-26T14.17.27 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.
  • 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.
• 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 the files in the src/scheduler package and generate a class diagram using mermaid and a README in the markdown format.

Support

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

CodeRabbit Commands (Invoked using PR/Issue comments)

Type @coderabbitai help to get the list of available commands.

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.

Status, Documentation and Community

• Visit our Status Page to check the current availability of CodeRabbit.
• 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.

[sonarqubecloud]

Quality Gate passed

Issues
0 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud

[codeflash-ai]

This PR has been automatically closed because the original PR #9539 by mendonk was closed.