⚡️ Speed up function check_api_key by 40% in PR #670 (vsc/environment-validation)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #670

If you approve this dependent PR, these changes will be merged into the original PR branch vsc/environment-validation.

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

---

📄 40% (0.40x) speedup for check_api_key in codeflash/lsp/beta.py

⏱️ Runtime : 6.60 milliseconds → 4.70 milliseconds (best of 59 runs)

📝 Explanation and details

The optimization replaces the expensive repeated import statement with a cached import pattern using a global variable and helper function.

Key optimization:

• Cached Import Pattern: The original code executes from codeflash.optimization.optimizer import Optimizer on every function call (line showing 4.6% of total time in profiler). The optimized version introduces _get_optimizer() which imports and caches the Optimizer class only once in the global _cached_optimizer variable.

Why this works:
Python imports are not free - they involve module lookup, loading, and namespace operations. While Python's import system caches modules internally, the from ... import ... statement still has overhead for symbol resolution on each execution. By caching the imported class reference, we eliminate this repeated work.

Performance impact:
The line profiler shows the import line went from 4.6% of execution time (12.3ms) to 3.8% (11.0ms) in the optimized version, contributing to the overall 40% speedup. This optimization is particularly effective for:

• High-frequency calls: The test results show consistent 36-43% improvements across all test cases
• Large-scale operations: The 1000-iteration tests maintain the same 40% improvement, demonstrating the optimization scales well
• Any scenario where check_api_key is called repeatedly: Since LSP servers typically handle many requests, this caching prevents redundant import overhead

The optimization maintains identical functionality while reducing per-call overhead through one-time import caching.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import builtins
from types import SimpleNamespace
from typing import Optional

# imports
import pytest  # used for our unit tests
from codeflash.lsp.beta import check_api_key


# Mocks and helpers for testing
class DummyOptimizer:
    def __init__(self, args):
        self.args = args

class DummyServer:
    def __init__(self, user_id=None, error_in_init=False, args=None, args_processed_before=False):
        self._user_id = user_id
        self.error_in_init = error_in_init
        self.args = args or SimpleNamespace()
        self.args_processed_before = args_processed_before
        self.optimizer = None
from codeflash.lsp.beta import check_api_key

# --- End: Code under test ---

# --- Begin: Unit tests ---

# 1. Basic Test Cases



def test_error_prefix_in_user_id_returns_error():
    # Test with user_id starting with "Error: "
    server = DummyServer(user_id="Error: some error message")
    codeflash_output = check_api_key(server, None); result = codeflash_output # 6.14μs -> 4.33μs (41.9% faster)

def test_successful_optimizer_assignment():
    # Test that optimizer is set on success
    server = DummyServer(user_id="user-456")
    codeflash_output = check_api_key(server, None); result = codeflash_output # 6.02μs -> 4.30μs (40.1% faster)

# 2. Edge Test Cases


def test_user_id_is_whitespace():
    # Edge: user_id is whitespace (should be treated as valid user id)
    server = DummyServer(user_id="   ")
    codeflash_output = check_api_key(server, None); result = codeflash_output # 5.92μs -> 4.13μs (43.4% faster)

def test_user_id_is_non_string():
    # Edge: user_id is an integer (should be treated as valid user id)
    server = DummyServer(user_id=12345)
    codeflash_output = check_api_key(server, None); result = codeflash_output # 5.69μs -> 4.11μs (38.5% faster)

def test_user_id_is_error_prefix_but_not_string():
    # Edge: user_id is not a string but starts with "Error: " if cast to string
    class WeirdUserId:
        def __str__(self): return "Error: fake"
    server = DummyServer(user_id=WeirdUserId())
    codeflash_output = check_api_key(server, None); result = codeflash_output # 5.95μs -> 4.33μs (37.5% faster)

def test_optimizer_init_raises_exception():
    # Edge: Optimizer creation raises, should return generic error
    server = DummyServer(user_id="user-789", error_in_init=True)
    codeflash_output = check_api_key(server, None); result = codeflash_output # 5.85μs -> 4.30μs (36.1% faster)

def test_user_id_callable():
    # Edge: user_id is a callable returning a string
    server = DummyServer(user_id=lambda: "user-xyz")
    codeflash_output = check_api_key(server, None); result = codeflash_output # 5.86μs -> 4.13μs (42.0% faster)

def test_user_id_callable_returns_none():
    # Edge: user_id is a callable returning None
    server = DummyServer(user_id=lambda: None)
    codeflash_output = check_api_key(server, None); result = codeflash_output # 5.75μs -> 4.08μs (41.0% faster)

def test_user_id_callable_returns_error_prefix():
    # Edge: user_id is a callable returning error prefix
    server = DummyServer(user_id=lambda: "Error: fail")
    codeflash_output = check_api_key(server, None); result = codeflash_output # 5.71μs -> 4.07μs (40.4% faster)

# 3. Large Scale Test Cases

def test_many_successful_api_keys():
    # Large scale: test with a large number of valid user_ids
    for i in range(1000):
        server = DummyServer(user_id=f"user-{i}")
        codeflash_output = check_api_key(server, None); result = codeflash_output # 2.18ms -> 1.55ms (40.5% faster)

def test_many_invalid_api_keys():
    # Large scale: test with a large number of None user_ids
    for i in range(1000):
        server = DummyServer(user_id=None)
        codeflash_output = check_api_key(server, None); result = codeflash_output # 2.17ms -> 1.55ms (40.5% faster)

def test_many_error_prefix_api_keys():
    # Large scale: test with a large number of error-prefixed user_ids
    for i in range(1000):
        server = DummyServer(user_id=f"Error: error-{i}")
        codeflash_output = check_api_key(server, None); result = codeflash_output # 2.17ms -> 1.55ms (40.1% faster)

def test_large_args_object():
    # Large scale: test with a large args object
    class LargeArgs:
        pass
    args = LargeArgs()
    # Add 1000 attributes
    for i in range(1000):
        setattr(args, f"attr_{i}", i)
    server = DummyServer(user_id="user-large", args=args)
    codeflash_output = check_api_key(server, None); result = codeflash_output # 7.68μs -> 5.64μs (36.2% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from __future__ import annotations

from functools import lru_cache
from types import SimpleNamespace
from typing import Optional

# imports
import pytest  # used for our unit tests
from codeflash.lsp.beta import check_api_key


class DummyServer:
    def __init__(self):
        self.args_processed_before = False
        self.args = SimpleNamespace()
        self.optimizer = None

    def feature(self, name):
        # Decorator passthrough for testability
        def decorator(fn):
            return fn
        return decorator

# Dummy process_pyproject_config returns args unchanged
def process_pyproject_config(args):
    return args

# Dummy Optimizer for testing
class Optimizer:
    def __init__(self, args):
        self.args = args

def process_args(server: DummyServer) -> SimpleNamespace:
    if server.args_processed_before:
        return server.args
    new_args = process_pyproject_config(server.args)
    server.args = new_args
    server.args_processed_before = True
    return new_args
from codeflash.lsp.beta import check_api_key

# --- End: Implementation under test ---

# --- Begin: Test helpers ---

# Helper for a get_user_id function that returns a given value
def make_get_user_id_fn(return_value):
    def fn():
        return return_value
    return fn

# --- End: Test helpers ---

# --- Begin: Unit tests ---

# 1. Basic Test Cases

To edit these changes git checkout codeflash/optimize-pr670-2025-08-21T11.43.15 and push.

[codeflash-ai]

This PR has been automatically closed because the original PR #670 by mohammedahmed18 was closed.