⚡️ Speed up method GoogleAIStudioFilesHandler.get_complete_url by 40%

[codeflash-ai]

📄 40% (0.40x) speedup for GoogleAIStudioFilesHandler.get_complete_url in litellm/llms/gemini/files/transformation.py

⏱️ Runtime : 789 microseconds → 562 microseconds (best of 195 runs)

📝 Explanation and details

The primary optimization is replacing the .format() method with an f-string for URL construction in the get_complete_url method.

Key Change:

• url = "{}/{}?key={}".format(api_base, endpoint, api_key) → url = f"{api_base}/{endpoint}?key={api_key}"

Why This Is Faster:
F-strings are compiled into bytecode that directly builds the string, while .format() involves method lookups, argument parsing, and additional function call overhead. The profiler shows the URL construction line improved from 951106 nanoseconds to 728844 nanoseconds (23% faster on that line alone).

Performance Impact:
The optimization delivers a 40% overall speedup, with individual test cases showing improvements ranging from 20% to 98% faster. The gains are most pronounced in scenarios with:

• Long strings (92-93% faster with long api_keys/api_bases)
• High-frequency calls (39-41% faster in large-scale tests)
• Simple URL construction patterns (60-98% faster in basic cases)

F-strings are particularly effective here because the URL pattern is straightforward with direct variable substitution, allowing the Python interpreter to optimize string concatenation more efficiently than the generic .format() method.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Optional

# imports
import pytest
from litellm.llms.gemini.files.transformation import GoogleAIStudioFilesHandler

# unit tests

# ----------- BASIC TEST CASES ------------

def test_basic_with_explicit_api_base_and_api_key():
    # Should construct correct URL using provided api_base and api_key
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://my.googleapis.com"
    api_key = "abc123"
    model = "gemini-pro"
    codeflash_output = handler.get_complete_url(api_base, api_key, model, {}, {}); url = codeflash_output # 2.24μs -> 1.15μs (94.6% faster)

def test_basic_with_secret_api_base():
    # Should fallback to secret manager for api_base if not provided
    handler = GoogleAIStudioFilesHandler()
    api_base = None
    api_key = "secretkey"
    model = "gemini-pro"
    codeflash_output = handler.get_complete_url(api_base, api_key, model, {}, {}); url = codeflash_output # 6.16μs -> 4.94μs (24.5% faster)

def test_basic_with_default_api_base():
    # Should fallback to hardcoded default if neither api_base nor secret present
    # Patch get_secret_str to return None for this test
    class Handler(GoogleAIStudioFilesHandler):
        @staticmethod
        def get_api_base(api_base: Optional[str] = None) -> Optional[str]:
            return api_base or None or "https://generativelanguage.googleapis.com"
    handler = Handler()
    api_base = None
    api_key = "defaultkey"
    model = "gemini-pro"
    codeflash_output = handler.get_complete_url(api_base, api_key, model, {}, {}); url = codeflash_output # 1.79μs -> 1.11μs (61.8% faster)

# ----------- EDGE TEST CASES ------------

def test_edge_missing_api_base_and_secret():
    # Should raise ValueError if api_base is None and no secret or default
    class Handler(GoogleAIStudioFilesHandler):
        @staticmethod
        def get_api_base(api_base: Optional[str] = None) -> Optional[str]:
            return None  # Simulate no api_base, no secret, no default
    handler = Handler()
    with pytest.raises(ValueError) as excinfo:
        handler.get_complete_url(None, "key", "model", {}, {}) # 1.34μs -> 1.38μs (2.68% slower)

def test_edge_missing_api_key():
    # Should raise ValueError if api_key is None
    handler = GoogleAIStudioFilesHandler()
    with pytest.raises(ValueError) as excinfo:
        handler.get_complete_url("https://my.googleapis.com", None, "model", {}, {}) # 1.68μs -> 1.48μs (13.1% faster)

def test_edge_empty_api_key():
    # Should raise ValueError if api_key is empty string
    handler = GoogleAIStudioFilesHandler()
    with pytest.raises(ValueError) as excinfo:
        handler.get_complete_url("https://my.googleapis.com", "", "model", {}, {}) # 1.52μs -> 1.37μs (11.3% faster)

def test_edge_api_base_with_trailing_slash():
    # Should handle api_base with trailing slash correctly (no double slash)
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://my.googleapis.com/"
    api_key = "abc123"
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 2.14μs -> 1.18μs (81.9% faster)

def test_edge_api_base_with_query_params():
    # Should not mangle api_base with existing query params
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://my.googleapis.com?existing=param"
    api_key = "abc123"
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 1.91μs -> 1.12μs (69.6% faster)

def test_edge_api_key_with_special_chars():
    # Should correctly include api_key with special characters
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://my.googleapis.com"
    api_key = "a!@#b$%^c&*()"
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 1.88μs -> 1.09μs (72.6% faster)

def test_edge_model_and_params_are_ignored():
    # Should ignore model, optional_params, litellm_params, stream
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://my.googleapis.com"
    api_key = "abc123"
    codeflash_output = handler.get_complete_url(api_base, api_key, "should_be_ignored", {"foo": "bar"}, {"baz": 123}, stream=True); url = codeflash_output # 2.20μs -> 1.34μs (63.9% faster)

# ----------- LARGE SCALE TEST CASES ------------

def test_large_scale_many_calls_different_keys():
    # Should handle many different api_keys efficiently and correctly
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://my.googleapis.com"
    for i in range(1000):  # Limit to 1000 for performance
        api_key = f"key{i}"
        codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 426μs -> 302μs (41.0% faster)

def test_large_scale_long_api_key():
    # Should handle very long api_key values
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://my.googleapis.com"
    api_key = "a" * 1000  # 1000 chars
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 2.70μs -> 1.40μs (92.4% faster)

def test_large_scale_long_api_base():
    # Should handle very long api_base values
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://my.googleapis.com" + "/subdir" * 100
    api_key = "abc123"
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 2.06μs -> 1.07μs (93.1% faster)
    expected = f"{api_base}/upload/v1beta/files?key=abc123"

def test_large_scale_different_models_and_params():
    # Should ignore model and params for URL generation, even with large dicts
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://my.googleapis.com"
    api_key = "abc123"
    model = "model"
    optional_params = {f"k{i}": f"v{i}" for i in range(500)}
    litellm_params = {f"p{i}": i for i in range(500)}
    codeflash_output = handler.get_complete_url(api_base, api_key, model, optional_params, litellm_params); url = codeflash_output # 1.82μs -> 984ns (85.5% faster)

# ----------- DETERMINISM TEST ------------

def test_determinism_same_inputs_same_output():
    # Should always return same output for same inputs
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://my.googleapis.com"
    api_key = "abc123"
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url1 = codeflash_output # 1.78μs -> 1.00μs (77.0% faster)
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url2 = codeflash_output # 710ns -> 482ns (47.3% faster)

# ----------- INVALID TYPE TESTS ------------

def test_invalid_api_key_type():
    # Should raise ValueError for non-string api_key
    handler = GoogleAIStudioFilesHandler()
    with pytest.raises(ValueError):
        handler.get_complete_url("https://my.googleapis.com", 12345, "model", {}, {})

def test_invalid_api_base_type():
    # Should raise ValueError if get_api_base returns non-string
    class Handler(GoogleAIStudioFilesHandler):
        @staticmethod
        def get_api_base(api_base: Optional[str] = None) -> Optional[str]:
            return 12345  # Invalid type
    handler = Handler()
    with pytest.raises(ValueError):
        handler.get_complete_url(None, "abc123", "model", {}, {})

# ----------- EXTRA EDGE CASES ------------

def test_edge_api_base_is_empty_string():
    # Should fallback to secret or default if api_base is empty string
    handler = GoogleAIStudioFilesHandler()
    api_base = ""
    api_key = "abc123"
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 7.65μs -> 6.19μs (23.6% faster)

def test_edge_api_key_is_whitespace():
    # Should treat whitespace-only api_key as invalid
    handler = GoogleAIStudioFilesHandler()
    with pytest.raises(ValueError):
        handler.get_complete_url("https://my.googleapis.com", "   ", "model", {}, {})

def test_edge_none_for_all_params():
    # Should raise ValueError if all params are None except required ones
    handler = GoogleAIStudioFilesHandler()
    with pytest.raises(ValueError):
        handler.get_complete_url(None, None, None, None, None) # 6.71μs -> 6.34μs (5.86% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from typing import Optional

# imports
import pytest
from litellm.llms.gemini.files.transformation import GoogleAIStudioFilesHandler


class BaseFilesConfig:
    pass
from litellm.llms.gemini.files.transformation import GoogleAIStudioFilesHandler

# Unit tests for get_complete_url

# ---- BASIC TEST CASES ----

def test_basic_valid_inputs():
    # Test with typical valid inputs
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://custom.googleapis.com"
    api_key = "my-key-123"
    model = "gemini-pro"
    optional_params = {}
    litellm_params = {}
    codeflash_output = handler.get_complete_url(api_base, api_key, model, optional_params, litellm_params); url = codeflash_output # 2.38μs -> 1.20μs (98.7% faster)

def test_basic_default_api_base():
    # Test when api_base is None, should use default from get_api_base
    handler = GoogleAIStudioFilesHandler()
    api_base = None
    api_key = "my-key-456"
    model = "gemini-pro"
    optional_params = {}
    litellm_params = {}
    codeflash_output = handler.get_complete_url(api_base, api_key, model, optional_params, litellm_params); url = codeflash_output # 6.13μs -> 5.09μs (20.4% faster)

def test_basic_different_model_and_params():
    # Model and params do not affect URL
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://api.google.com"
    api_key = "key789"
    model = "gemini-ultra"
    optional_params = {"foo": "bar"}
    litellm_params = {"baz": 42}
    codeflash_output = handler.get_complete_url(api_base, api_key, model, optional_params, litellm_params); url = codeflash_output # 1.97μs -> 1.09μs (80.5% faster)

# ---- EDGE TEST CASES ----

def test_edge_missing_api_base_and_no_fallback(monkeypatch):
    # Simulate get_api_base returning None (simulate secret manager returns None)
    class TestHandler(GoogleAIStudioFilesHandler):
        @staticmethod
        def get_api_base(api_base):
            return None
    handler = TestHandler()
    with pytest.raises(ValueError) as excinfo:
        handler.get_complete_url(None, "test-key", "model", {}, {}) # 1.36μs -> 1.42μs (3.81% slower)

def test_edge_missing_api_key():
    # api_key is None, should raise ValueError
    handler = GoogleAIStudioFilesHandler()
    with pytest.raises(ValueError) as excinfo:
        handler.get_complete_url("https://api.google.com", None, "model", {}, {}) # 1.77μs -> 1.48μs (19.4% faster)

def test_edge_empty_api_key():
    # api_key is empty string, should raise ValueError
    handler = GoogleAIStudioFilesHandler()
    with pytest.raises(ValueError) as excinfo:
        handler.get_complete_url("https://api.google.com", "", "model", {}, {}) # 1.67μs -> 1.37μs (22.0% faster)

def test_edge_empty_api_base():
    # api_base is empty string, should raise ValueError
    handler = GoogleAIStudioFilesHandler()
    with pytest.raises(ValueError) as excinfo:
        handler.get_complete_url("", "key", "model", {}, {})

def test_edge_special_characters_in_api_key():
    # api_key contains special characters
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://api.google.com"
    api_key = "key!@#$%^&*()"
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 2.56μs -> 1.46μs (75.1% faster)

def test_edge_api_base_with_trailing_slash():
    # api_base ends with a slash
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://api.google.com/"
    api_key = "abc123"
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 2.06μs -> 1.15μs (79.2% faster)

def test_edge_api_base_with_spaces():
    # api_base contains spaces
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://api .google.com"
    api_key = "testkey"
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 1.92μs -> 1.06μs (81.7% faster)

def test_edge_api_key_with_spaces():
    # api_key contains spaces
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://api.google.com"
    api_key = "key with spaces"
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 1.93μs -> 1.08μs (77.6% faster)

def test_edge_model_and_params_are_none():
    # model, optional_params, litellm_params are None/empty, should not affect URL
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://api.google.com"
    api_key = "key"
    codeflash_output = handler.get_complete_url(api_base, api_key, None, None, None); url = codeflash_output # 1.90μs -> 1.08μs (76.8% faster)

def test_edge_stream_true_false_none():
    # stream parameter does not affect URL
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://api.google.com"
    api_key = "key"
    for stream_val in [True, False, None]:
        codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}, stream=stream_val); url = codeflash_output # 3.48μs -> 2.28μs (52.6% faster)

# ---- LARGE SCALE TEST CASES ----

def test_large_scale_many_calls():
    # Test function performance and determinism with many calls
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://api.google.com"
    # Use 500 different api_keys
    for i in range(500):
        api_key = f"key_{i}"
        codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 215μs -> 154μs (39.5% faster)

def test_large_scale_long_api_key():
    # Test with a very long api_key (1000 chars)
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://api.google.com"
    api_key = "k" * 1000
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 2.44μs -> 1.40μs (73.8% faster)

def test_large_scale_long_api_base():
    # Test with a very long api_base (1000 chars)
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://" + "a" * 990  # 990 + 8 = 998 + 2 for '//' = 1000
    api_key = "key"
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 2.14μs -> 1.25μs (71.1% faster)

def test_large_scale_long_model_and_params():
    # Very large model string and params dict
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://api.google.com"
    api_key = "key"
    model = "m" * 1000
    optional_params = {str(i): i for i in range(1000)}
    litellm_params = {str(i): i for i in range(1000)}
    codeflash_output = handler.get_complete_url(api_base, api_key, model, optional_params, litellm_params); url = codeflash_output # 1.84μs -> 1.03μs (77.7% faster)

def test_large_scale_unique_api_base_and_key_combinations():
    # Test many unique combinations
    handler = GoogleAIStudioFilesHandler()
    for i in range(100):
        api_base = f"https://api{i}.google.com"
        api_key = f"key{i}"
        codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 45.6μs -> 32.3μs (41.3% faster)

# ---- DETERMINISM & MUTATION RESISTANCE ----

def test_mutation_resistance_api_key_must_be_in_url():
    # If api_key is not in URL, test fails
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://api.google.com"
    api_key = "abc"
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 1.70μs -> 880ns (93.3% faster)

def test_mutation_resistance_endpoint_must_be_in_url():
    # If endpoint changes, test fails
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://api.google.com"
    api_key = "abc"
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 1.60μs -> 935ns (71.0% faster)

def test_mutation_resistance_api_base_must_be_in_url():
    # If api_base is missing, test fails
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://api.google.com"
    api_key = "abc"
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {}, {}); url = codeflash_output # 1.61μs -> 963ns (67.5% faster)

def test_mutation_resistance_no_extra_query_params():
    # No extra params should be added to the URL
    handler = GoogleAIStudioFilesHandler()
    api_base = "https://api.google.com"
    api_key = "abc"
    codeflash_output = handler.get_complete_url(api_base, api_key, "model", {"foo": "bar"}, {"baz": 42}); url = codeflash_output # 1.61μs -> 913ns (76.6% 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.llms.gemini.files.transformation import GoogleAIStudioFilesHandler
import pytest

def test_GoogleAIStudioFilesHandler_get_complete_url():
    GoogleAIStudioFilesHandler.get_complete_url(GoogleAIStudioFilesHandler(), '', '\x00', '', {}, {}, stream=None)

def test_GoogleAIStudioFilesHandler_get_complete_url_2():
    with pytest.raises(ValueError, match='api_key\\ is\\ required'):
        GoogleAIStudioFilesHandler.get_complete_url(GoogleAIStudioFilesHandler(), '', '', '', {}, {}, stream=None)

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_evt0erui/tmp9e2jncv7/test_concolic_coverage.py::test_GoogleAIStudioFilesHandler_get_complete_url	7.60μs	6.53μs	16.5%✅
codeflash_concolic_evt0erui/tmp9e2jncv7/test_concolic_coverage.py::test_GoogleAIStudioFilesHandler_get_complete_url_2	5.45μs	5.28μs	3.20%✅

To edit these changes git checkout codeflash/optimize-GoogleAIStudioFilesHandler.get_complete_url-mhbso61o and push.