⚡️ Speed up function extract_query_params by 110%

[codeflash-ai]

📄 110% (1.10x) speedup for extract_query_params in src/titiler/core/titiler/core/utils.py

⏱️ Runtime : 57.2 milliseconds → 27.2 milliseconds (best of 214 runs)

📝 Explanation and details

The optimized code achieves a 109% speedup through two key optimizations that target the most expensive operations:

1. Caching get_dependant Results (78% of time savings)
The original code calls get_dependant(path="", call=dependency) on every invocation, which the profiler shows takes 68.8% of execution time (157ms out of 228ms). The optimization adds function-level caching using a _titiler_gdp_cached_dep attribute on each dependency callable. When the same dependency is processed multiple times, subsequent calls retrieve the cached result instead of re-analyzing the dependency structure.

2. Hoisting QueryParams Creation (Additional efficiency)
In extract_query_params, the original code performed isinstance(params, Dict) and urlencode() inside get_dependency_query_params for every dependency. The optimization moves this check outside the loop, converting Dict to QueryParams once and reusing it across all dependencies.

Performance Impact by Test Case:

• Repeated dependencies see dramatic gains (995% faster for 100 identical dependencies)
• Single dependency calls show 6-8x improvements due to reduced get_dependant overhead
• Large-scale scenarios benefit most, with 50+ dependencies seeing 55-99% speedups
• Simple cases still improve significantly (261-795% faster)

The caching is safe because get_dependant results are deterministic per callable and don't change during runtime. These optimizations are particularly valuable in web frameworks where the same dependencies are processed repeatedly across requests.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

🌀 Generated Regression Tests and Runtime

from typing import Any, Callable, Dict, List, Tuple, Union
from urllib.parse import urlencode

# imports
import pytest
from fastapi.datastructures import QueryParams
# --- Copy-paste of the function under test (from prompt) ---
from fastapi.dependencies.utils import get_dependant, request_params_to_args
from titiler.core.utils import extract_query_params

# We'll need to define dummy dependencies for the test cases.
# These are simple callables that mimic FastAPI dependency signatures.

def dep_no_params():
    return {}

def dep_one_param(foo: str):
    return {"foo": foo}

def dep_multi_params(foo: str, bar: int):
    return {"foo": foo, "bar": bar}

def dep_with_default(foo: str = "default"):
    return {"foo": foo}

def dep_with_optional(bar: int = None):
    return {"bar": bar}

def dep_type_coercion(x: int, y: float):
    return {"x": x, "y": y}

def dep_bool(flag: bool = False):
    return {"flag": flag}

def dep_list_param(items: List[int]):
    return {"items": items}

def dep_union_param(u: Union[int, str]):
    return {"u": u}

def dep_raise(foo: int):
    # Simulate a dependency that raises if input is not int
    if not isinstance(foo, int):
        raise ValueError("foo must be int")
    return {"foo": foo}

ValidParams = Dict[str, Any]
Errors = List[Any]
from titiler.core.utils import extract_query_params

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

# 1. BASIC TEST CASES

def test_no_dependencies():
    """No dependencies: should return empty dict and list."""
    values, errors = extract_query_params([], {}) # 572ns -> 6.90μs (91.7% slower)

def test_single_dependency_no_params():
    """Single dependency, no params required."""
    values, errors = extract_query_params([dep_no_params], {}) # 29.5μs -> 8.16μs (261% faster)

def test_single_dependency_one_param():
    """Single dependency, one param provided."""
    values, errors = extract_query_params([dep_one_param], {"foo": "bar"}) # 285μs -> 34.0μs (741% faster)

def test_single_dependency_one_param_missing():
    """Single dependency, required param missing should result in error."""
    values, errors = extract_query_params([dep_one_param], {}) # 257μs -> 32.1μs (701% faster)

def test_single_dependency_with_default():
    """Dependency with default param, param omitted."""
    values, errors = extract_query_params([dep_with_default], {}) # 253μs -> 28.3μs (795% faster)

def test_single_dependency_with_default_overridden():
    """Dependency with default param, param provided."""
    values, errors = extract_query_params([dep_with_default], {"foo": "baz"}) # 255μs -> 31.5μs (711% faster)

def test_multiple_dependencies_disjoint_params():
    """Multiple dependencies, disjoint params."""
    values, errors = extract_query_params([dep_one_param, dep_with_default], {"foo": "abc"}) # 465μs -> 41.5μs (1021% faster)

def test_multiple_dependencies_overlapping_params():
    """Multiple dependencies, overlapping param names."""
    values, errors = extract_query_params([dep_one_param, dep_multi_params], {"foo": "abc", "bar": 123}) # 617μs -> 61.8μs (899% faster)

def test_dependency_type_coercion():
    """Dependency with int and float params, provided as strings."""
    values, errors = extract_query_params([dep_type_coercion], {"x": "5", "y": "2.5"}) # 405μs -> 52.6μs (670% faster)

def test_dependency_bool_flag_true():
    """Dependency with bool param, provided as 'true'."""
    values, errors = extract_query_params([dep_bool], {"flag": "true"}) # 251μs -> 36.7μs (586% faster)

def test_dependency_bool_flag_false():
    """Dependency with bool param, provided as 'false'."""
    values, errors = extract_query_params([dep_bool], {"flag": "false"}) # 250μs -> 35.8μs (600% faster)

def test_dependency_list_param():
    """Dependency with list param, provided as repeated query param."""
    values, errors = extract_query_params([dep_list_param], {"items": ["1", "2", "3"]}) # 289μs -> 18.1μs (1506% faster)

def test_dependency_union_param_int():
    """Dependency with Union[int, str], provided as int."""
    values, errors = extract_query_params([dep_union_param], {"u": "42"}) # 347μs -> 43.8μs (692% faster)

def test_dependency_union_param_str():
    """Dependency with Union[int, str], provided as non-int."""
    values, errors = extract_query_params([dep_union_param], {"u": "hello"}) # 338μs -> 42.2μs (702% faster)

# 2. EDGE TEST CASES

def test_empty_params_dict():
    """Empty params dict with dependency expecting default."""
    values, errors = extract_query_params([dep_with_default], {}) # 253μs -> 26.8μs (846% faster)

def test_empty_params_queryparams():
    """Empty QueryParams object."""
    values, errors = extract_query_params([dep_with_default], QueryParams("")) # 240μs -> 20.9μs (1054% faster)

def test_params_with_extra_keys():
    """Params dict has extra keys not required by dependencies."""
    values, errors = extract_query_params([dep_one_param], {"foo": "bar", "baz": "ignore"}) # 249μs -> 34.1μs (633% faster)

def test_missing_required_param():
    """Missing required param should yield error."""
    values, errors = extract_query_params([dep_multi_params], {"foo": "abc"}) # 417μs -> 52.0μs (704% faster)

def test_param_wrong_type():
    """Param of wrong type should yield error."""
    values, errors = extract_query_params([dep_multi_params], {"foo": "abc", "bar": "not_an_int"}) # 406μs -> 56.9μs (615% faster)

def test_dependency_raises():
    """Dependency raises error on invalid input."""
    values, errors = extract_query_params([dep_raise], {"foo": "not_an_int"}) # 255μs -> 42.8μs (497% faster)

def test_param_none_value():
    """Param explicitly set to None (should be ignored or error)."""
    values, errors = extract_query_params([dep_one_param], {"foo": None}) # 239μs -> 31.3μs (666% faster)

def test_dependency_with_optional_param_missing():
    """Optional param missing: should be None."""
    values, errors = extract_query_params([dep_with_optional], {}) # 251μs -> 28.8μs (773% faster)

def test_dependency_with_optional_param_provided():
    """Optional param provided."""
    values, errors = extract_query_params([dep_with_optional], {"bar": "7"}) # 261μs -> 36.1μs (623% faster)

def test_dependency_list_param_empty():
    """List param provided as empty list."""
    values, errors = extract_query_params([dep_list_param], {"items": []}) # 281μs -> 10.4μs (2615% faster)

def test_dependency_list_param_single():
    """List param provided as single value."""
    values, errors = extract_query_params([dep_list_param], {"items": "5"}) # 275μs -> 14.1μs (1859% faster)

def test_dependency_list_param_comma_separated():
    """List param provided as comma-separated string."""
    values, errors = extract_query_params([dep_list_param], {"items": "1,2,3"}) # 284μs -> 22.9μs (1146% faster)
    # Accept any of these, as behavior may depend on implementation

# 3. LARGE SCALE TEST CASES

def test_many_dependencies():
    """Test with a large number of dependencies (<=100)."""
    def make_dep(n):
        return lambda x: {"x": int(x) + n}
    deps = [make_dep(i) for i in range(100)]
    params = {"x": "1"}
    values, errors = extract_query_params(deps, params) # 16.6ms -> 15.6ms (7.00% faster)

def test_many_params():
    """Test with a dependency expecting many params."""
    def dep_many(**kwargs):
        return kwargs
    params = {f"key{i}": str(i) for i in range(100)}
    # Create a dependency that takes all these keys as keyword arguments
    def dep(**kwargs):
        return kwargs
    values, errors = extract_query_params([dep], params) # 405μs -> 426μs (5.05% slower)

def test_large_list_param():
    """Dependency with a large list param."""
    items = [str(i) for i in range(500)]
    values, errors = extract_query_params([dep_list_param], {"items": items}) # 824μs -> 502μs (64.0% faster)

def test_large_number_of_disjoint_dependencies():
    """Test with many dependencies, each expecting a unique param."""
    def make_dep(i):
        def dep(x: int):
            return {f"x{i}": x}
        dep.__name__ = f"dep_{i}"
        dep.__annotations__ = {"x": int}
        return dep
    deps = [make_dep(i) for i in range(50)]
    params = {f"x{i}": str(i) for i in range(50)}
    values, errors = extract_query_params(deps, params) # 12.6ms -> 8.12ms (55.2% faster)

def test_large_number_of_overlapping_dependencies():
    """Test with many dependencies, all expecting the same param name."""
    def dep(x: int):
        return {"x": x}
    deps = [dep for _ in range(100)]
    params = {"x": "42"}
    values, errors = extract_query_params(deps, params) # 17.9ms -> 1.64ms (995% faster)
# 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-extract_query_params-mi8cxfoj and push.