⚡️ Speed up function get_proxy_base_url by 5%

[codeflash-ai]

📄 5% (0.05x) speedup for get_proxy_base_url in litellm/proxy/utils.py

⏱️ Runtime : 333 microseconds → 316 microseconds (best of 564 runs)

📝 Explanation and details

The optimization replaces os.getenv("PROXY_BASE_URL") with os.environ.get("PROXY_BASE_URL") and stores the result in a variable before returning it.

Key Performance Improvement:

• os.getenv() is a wrapper function that adds overhead by calling os.environ.get() internally with additional argument processing
• Direct use of os.environ.get() eliminates this function call layer, reducing execution time by ~5-12% across test cases

Why This Works:

• The line profiler shows the optimized version has lower per-hit execution time (2956ns vs 3191ns per call)
• Both methods have identical behavior and return types, but os.environ.get() has less overhead
• The variable assignment adds minimal cost (215ns) but is negligible compared to the savings from avoiding the wrapper function

Test Case Performance:

• Consistent 4-18% improvements across all scenarios (existing env vars, missing env vars, unicode strings, long strings)
• Best performance gains on cases where the environment variable doesn't exist (12.9-18.5% faster), likely due to reduced overhead in the lookup path
• Even large-scale repeated calls show 4-6% improvements, demonstrating the optimization scales well

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import os

# imports
import pytest  # used for our unit tests
from litellm.proxy.utils import get_proxy_base_url

# unit tests

@pytest.mark.basic
def test_basic_existing_env_var():
    """Test when PROXY_BASE_URL is set to a typical URL."""
    os.environ["PROXY_BASE_URL"] = "https://example.com/api"
    codeflash_output = get_proxy_base_url() # 1.46μs -> 1.34μs (9.27% faster)
    del os.environ["PROXY_BASE_URL"]

@pytest.mark.basic
def test_basic_empty_env_var():
    """Test when PROXY_BASE_URL is set to an empty string."""
    os.environ["PROXY_BASE_URL"] = ""
    codeflash_output = get_proxy_base_url() # 1.34μs -> 1.23μs (8.69% faster)
    del os.environ["PROXY_BASE_URL"]

@pytest.mark.basic
def test_basic_env_var_not_set():
    """Test when PROXY_BASE_URL is not set at all."""
    if "PROXY_BASE_URL" in os.environ:
        del os.environ["PROXY_BASE_URL"]
    codeflash_output = get_proxy_base_url() # 1.59μs -> 1.41μs (12.9% faster)

@pytest.mark.basic
def test_basic_env_var_set_to_none_string():
    """Test when PROXY_BASE_URL is set to the string 'None'."""
    os.environ["PROXY_BASE_URL"] = "None"
    codeflash_output = get_proxy_base_url() # 1.36μs -> 1.29μs (4.79% faster)
    del os.environ["PROXY_BASE_URL"]

@pytest.mark.edge
def test_edge_env_var_set_to_whitespace():
    """Test when PROXY_BASE_URL is set to whitespace only."""
    os.environ["PROXY_BASE_URL"] = "   "
    codeflash_output = get_proxy_base_url() # 1.39μs -> 1.28μs (8.57% faster)
    del os.environ["PROXY_BASE_URL"]

@pytest.mark.edge
def test_edge_env_var_set_to_special_characters():
    """Test when PROXY_BASE_URL contains special characters."""
    os.environ["PROXY_BASE_URL"] = "!@#$%^&*()_+-=[]{}|;':,.<>/?"
    codeflash_output = get_proxy_base_url() # 1.39μs -> 1.28μs (8.59% faster)
    del os.environ["PROXY_BASE_URL"]

@pytest.mark.edge
def test_edge_env_var_set_to_unicode():
    """Test when PROXY_BASE_URL contains unicode characters."""
    os.environ["PROXY_BASE_URL"] = "https://例子.测试/路径"
    codeflash_output = get_proxy_base_url() # 2.23μs -> 2.18μs (2.48% faster)
    del os.environ["PROXY_BASE_URL"]

@pytest.mark.edge
def test_edge_env_var_set_to_long_string():
    """Test when PROXY_BASE_URL is set to a very long string (1000 chars)."""
    long_url = "http://" + "a" * 990
    os.environ["PROXY_BASE_URL"] = long_url
    codeflash_output = get_proxy_base_url() # 1.80μs -> 1.71μs (4.90% faster)
    del os.environ["PROXY_BASE_URL"]

@pytest.mark.edge
def test_edge_env_var_set_to_newline():
    """Test when PROXY_BASE_URL contains a newline character."""
    os.environ["PROXY_BASE_URL"] = "https://example.com/api\n"
    codeflash_output = get_proxy_base_url() # 1.32μs -> 1.29μs (2.01% faster)
    del os.environ["PROXY_BASE_URL"]

@pytest.mark.large
def test_large_scale_multiple_env_var_changes():
    """
    Test changing PROXY_BASE_URL many times in succession to ensure no caching occurs.
    """
    for i in range(100):
        url = f"https://example.com/api/{i}"
        os.environ["PROXY_BASE_URL"] = url
        codeflash_output = get_proxy_base_url() # 67.8μs -> 63.6μs (6.68% faster)
    del os.environ["PROXY_BASE_URL"]

@pytest.mark.large
def test_large_scale_long_unicode_string():
    """
    Test with a long unicode string (1000 chars) as PROXY_BASE_URL.
    """
    long_unicode = "🌍" * 1000
    os.environ["PROXY_BASE_URL"] = long_unicode
    codeflash_output = get_proxy_base_url() # 4.95μs -> 4.85μs (2.12% faster)
    del os.environ["PROXY_BASE_URL"]

@pytest.mark.large
def test_large_scale_env_var_not_set_repeated():
    """
    Test calling get_proxy_base_url repeatedly when env var is not set.
    Should always return None.
    """
    if "PROXY_BASE_URL" in os.environ:
        del os.environ["PROXY_BASE_URL"]
    for _ in range(200):
        codeflash_output = get_proxy_base_url() # 152μs -> 145μs (4.34% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import os

# imports
import pytest  # used for our unit tests
from litellm.proxy.utils import get_proxy_base_url

# unit tests

# --- BASIC TEST CASES ---

def test_returns_none_when_env_not_set():
    """
    Test that the function returns None if the environment variable is not set.
    """
    # Ensure the variable is not set
    if "PROXY_BASE_URL" in os.environ:
        del os.environ["PROXY_BASE_URL"]
    codeflash_output = get_proxy_base_url() # 1.54μs -> 1.30μs (18.5% faster)

def test_returns_value_when_env_is_set():
    """
    Test that the function returns the correct value when the environment variable is set.
    """
    os.environ["PROXY_BASE_URL"] = "http://localhost:8000"
    codeflash_output = get_proxy_base_url() # 1.41μs -> 1.30μs (8.20% faster)
    # Clean up
    del os.environ["PROXY_BASE_URL"]

def test_returns_empty_string_when_env_is_set_to_empty():
    """
    Test that the function returns an empty string when the environment variable is set to an empty string.
    """
    os.environ["PROXY_BASE_URL"] = ""
    codeflash_output = get_proxy_base_url() # 1.38μs -> 1.26μs (9.77% faster)
    del os.environ["PROXY_BASE_URL"]

def test_returns_value_with_special_characters():
    """
    Test that the function correctly returns values with special characters.
    """
    special_url = "https://user:pass@host:8080/path?query=param#fragment"
    os.environ["PROXY_BASE_URL"] = special_url
    codeflash_output = get_proxy_base_url() # 1.39μs -> 1.27μs (9.61% faster)
    del os.environ["PROXY_BASE_URL"]

# --- EDGE TEST CASES ---

def test_returns_value_with_unicode_characters():
    """
    Test that the function returns a value containing Unicode characters.
    """
    unicode_url = "https://例子.测试/路径"
    os.environ["PROXY_BASE_URL"] = unicode_url
    codeflash_output = get_proxy_base_url() # 2.25μs -> 2.12μs (6.03% faster)
    del os.environ["PROXY_BASE_URL"]

def test_returns_value_with_whitespace():
    """
    Test that the function returns a value containing whitespace.
    """
    whitespace_url = "  http://localhost:8000  "
    os.environ["PROXY_BASE_URL"] = whitespace_url
    codeflash_output = get_proxy_base_url() # 1.34μs -> 1.27μs (5.18% faster)
    del os.environ["PROXY_BASE_URL"]

def test_returns_value_with_long_url():
    """
    Test that the function returns a very long URL string.
    """
    long_url = "http://localhost:8000/" + "a" * 500
    os.environ["PROXY_BASE_URL"] = long_url
    codeflash_output = get_proxy_base_url() # 1.51μs -> 1.44μs (4.78% faster)
    del os.environ["PROXY_BASE_URL"]

def test_returns_value_with_non_url_string():
    """
    Test that the function returns a non-URL string if set.
    """
    os.environ["PROXY_BASE_URL"] = "not_a_url"
    codeflash_output = get_proxy_base_url() # 1.25μs -> 1.24μs (0.884% faster)
    del os.environ["PROXY_BASE_URL"]

def test_returns_value_with_newline_characters():
    """
    Test that the function returns a value containing newline characters.
    """
    newline_url = "http://localhost:8000\nanotherline"
    os.environ["PROXY_BASE_URL"] = newline_url
    codeflash_output = get_proxy_base_url() # 1.42μs -> 1.23μs (16.2% faster)
    del os.environ["PROXY_BASE_URL"]

# --- LARGE SCALE TEST CASES ---

def test_returns_value_with_max_env_length():
    """
    Test that the function returns a very large string (close to OS environment variable limits).
    Most OSes allow at least 32767 bytes, but we'll use 1000 for safety.
    """
    large_url = "http://localhost:8000/" + "x" * 1000
    os.environ["PROXY_BASE_URL"] = large_url
    codeflash_output = get_proxy_base_url() # 1.75μs -> 1.60μs (8.85% faster)
    del os.environ["PROXY_BASE_URL"]

def test_multiple_calls_consistency():
    """
    Test that multiple calls to the function return the same value if the environment variable is unchanged.
    """
    url = "http://localhost:8000"
    os.environ["PROXY_BASE_URL"] = url
    for _ in range(100):  # 100 is large enough for this test
        codeflash_output = get_proxy_base_url() # 66.3μs -> 63.0μs (5.16% faster)
    del os.environ["PROXY_BASE_URL"]

def test_bulk_env_var_changes():
    """
    Test that the function correctly returns updated values when the environment variable changes rapidly.
    """
    for i in range(10):  # 10 different values
        url = f"http://localhost:{8000+i}"
        os.environ["PROXY_BASE_URL"] = url
        codeflash_output = get_proxy_base_url() # 7.51μs -> 7.04μs (6.65% faster)
    del os.environ["PROXY_BASE_URL"]

def test_returns_none_after_env_var_deleted():
    """
    Test that the function returns None after the environment variable is deleted.
    """
    os.environ["PROXY_BASE_URL"] = "http://localhost:8000"
    codeflash_output = get_proxy_base_url() # 1.30μs -> 1.19μs (9.86% faster)
    del os.environ["PROXY_BASE_URL"]
    codeflash_output = get_proxy_base_url() # 1.79μs -> 1.70μs (5.60% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from litellm.proxy.utils import get_proxy_base_url

def test_get_proxy_base_url():
    get_proxy_base_url()

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_evt0erui/tmptx3__ja4/test_concolic_coverage.py::test_get_proxy_base_url	2.19μs	2.03μs	7.83%✅

To edit these changes git checkout codeflash/optimize-get_proxy_base_url-mhbq3bcv and push.