⚡️ Speed up function deserialize_query_params by 6%

[codeflash-ai]

📄 6% (0.06x) speedup for deserialize_query_params in src/titiler/core/titiler/core/utils.py

⏱️ Runtime : 54.8 milliseconds → 51.6 milliseconds (best of 41 runs)

📝 Explanation and details

The optimized code achieves a 6% speedup through dependency introspection caching. The key optimization is memoizing the expensive get_dependant() calls using a function attribute cache.

What changed:

• Added a simple cache (_dependants dictionary) stored as a function attribute to memoize get_dependant() results per dependency callable
• Streamlined the QueryParams construction logic by removing the ternary operator in favor of explicit if/else branches

Why it's faster:
The line profiler shows that get_dependant(path="", call=dependency) was the bottleneck, consuming 81.4% of execution time in the original code. This function performs expensive introspection on the callable to extract parameter metadata. In the optimized version, this expensive operation is reduced from 53 hits to only 41 hits due to caching, dropping its contribution to 80.4% while adding minimal cache overhead.

Performance characteristics:

• Cache hits provide dramatic speedups: Test cases show improvements ranging from 200-850% faster for repeated calls with the same dependency
• Cache misses have minimal overhead: First-time calls show only slight slowdowns (1-3%) due to cache setup
• Large-scale workloads benefit most: Tests with many parameters show 1-2% improvements, indicating the optimization scales well

Impact on workloads:
Since this function is likely called repeatedly with the same dependency callables (common in web frameworks for parameter validation), the caching provides cumulative benefits. The optimization is particularly effective for applications that process many requests using the same endpoint dependencies, which is typical in FastAPI-based services.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 6 Passed
🌀 Generated Regression Tests	✅ 42 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 __future__ import annotations

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

# imports
import pytest
from fastapi import Query
from fastapi.datastructures import QueryParams
from fastapi.dependencies.utils import get_dependant, request_params_to_args
from titiler.core.utils import deserialize_query_params

T = TypeVar("T")
Errors = List[Any]
from titiler.core.utils import deserialize_query_params

# ========== UNIT TESTS ==========

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

def test_single_string_param():
    # Test deserialization of a single string parameter
    def dep(foo: str):
        return foo
    result, errors = deserialize_query_params(dep, {"foo": "bar"}) # 253μs -> 289μs (12.6% slower)

def test_multiple_basic_types():
    # Test deserialization of multiple basic types
    def dep(a: int, b: float, c: str):
        return (a, b, c)
    result, errors = deserialize_query_params(dep, {"a": "1", "b": "2.5", "c": "hello"}) # 571μs -> 578μs (1.13% slower)

def test_optional_param_present():
    # Test optional parameter provided
    def dep(a: int, b: Optional[str] = None):
        return (a, b)
    result, errors = deserialize_query_params(dep, {"a": "7", "b": "x"}) # 483μs -> 494μs (2.21% slower)

def test_optional_param_missing():
    # Test optional parameter missing (should use default)
    def dep(a: int, b: Optional[str] = None):
        return (a, b)
    result, errors = deserialize_query_params(dep, {"a": "7"}) # 479μs -> 478μs (0.212% faster)

def test_query_param_with_default():
    # Test parameter with default value using Query
    def dep(a: int = Query(10)):
        return a
    result, errors = deserialize_query_params(dep, {}) # 217μs -> 217μs (0.071% faster)

def test_empty_params():
    # Test with no parameters and all defaults
    def dep(a: int = 1, b: str = "test"):
        return (a, b)
    result, errors = deserialize_query_params(dep, {}) # 469μs -> 469μs (0.032% slower)

def test_extra_param_ignored():
    # Test extra parameter not in dependency (should be ignored)
    def dep(a: int):
        return a
    result, errors = deserialize_query_params(dep, {"a": "1", "extra": "ignoreme"}) # 316μs -> 312μs (1.20% faster)

def test_bool_param_true_false():
    # Test boolean parameter with various representations
    def dep(flag: bool):
        return flag
    for val in ["true", "True", "1", "on", "yes"]:
        result, errors = deserialize_query_params(dep, {"flag": val}) # 1.06ms -> 351μs (201% faster)
    for val in ["false", "False", "0", "off", "no"]:
        result, errors = deserialize_query_params(dep, {"flag": val}) # 868μs -> 93.6μs (827% faster)

def test_list_param_empty():
    # Test list parameter with no values (should be empty list)
    def dep(items: List[int] = Query([])):
        return items
    result, errors = deserialize_query_params(dep, {}) # 293μs -> 302μs (3.11% slower)

def test_param_with_underscore():
    # Test parameter with underscore in name
    def dep(my_param: int):
        return my_param
    result, errors = deserialize_query_params(dep, {"my_param": "42"}) # 260μs -> 261μs (0.626% slower)

def test_queryparams_object_input():
    # Test passing QueryParams object instead of dict
    def dep(a: int):
        return a
    qp = QueryParams("a=123")
    result, errors = deserialize_query_params(dep, qp) # 234μs -> 238μs (1.94% slower)

def test_param_with_special_characters():
    # Test parameter value with special characters
    def dep(name: str):
        return name
    result, errors = deserialize_query_params(dep, {"name": "John+Doe%20Test"}) # 251μs -> 251μs (0.028% slower)

def test_param_with_none_string():
    # Test string "None" for optional param should not be converted to None
    def dep(a: Optional[str] = None):
        return a
    result, errors = deserialize_query_params(dep, {"a": "None"}) # 331μs -> 330μs (0.211% faster)

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

def test_large_number_of_simple_params():
    # Test function with a large number of simple int parameters
    def make_dep(n):
        # Dynamically create a function with n int parameters
        code = "def dep(" + ", ".join(f"p{i}: int" for i in range(n)) + "):\n"
        code += "    return [" + ", ".join(f"p{i}" for i in range(n)) + "]\n"
        ns = {}
        exec(code, ns)
        return ns['dep']
    n = 100  # keep <1000 as per instructions
    dep = make_dep(n)
    params = {f"p{i}": str(i) for i in range(n)}
    result, errors = deserialize_query_params(dep, params) # 13.7ms -> 13.6ms (1.10% faster)

def test_large_mixed_types():
    # Test function with many mixed-type parameters
    def make_dep(n):
        code = "def dep(" + ", ".join(
            f"a{i}: int, b{i}: float, c{i}: str" for i in range(n)
        ) + "):\n"
        code += "    return ["
        code += ", ".join(f"(a{i}, b{i}, c{i})" for i in range(n))
        code += "]\n"
        ns = {}
        exec(code, ns)
        return ns['dep']
    n = 20  # 20*3 = 60 params, reasonable for test
    dep = make_dep(n)
    params = {}
    for i in range(n):
        params[f"a{i}"] = str(i)
        params[f"b{i}"] = str(i + 0.5)
        params[f"c{i}"] = f"str{i}"
    result, errors = deserialize_query_params(dep, params) # 8.38ms -> 8.21ms (2.08% faster)
    expected = [(i, i + 0.5, f"str{i}") for i in range(n)]

def test_large_scale_missing_required():
    # Test many parameters, some missing required, should raise TypeError
    def make_dep(n):
        code = "def dep(" + ", ".join(f"p{i}: int" for i in range(n)) + "):\n"
        code += "    return [" + ", ".join(f"p{i}" for i in range(n)) + "]\n"
        ns = {}
        exec(code, ns)
        return ns['dep']
    n = 50
    dep = make_dep(n)
    # Provide only half the parameters
    params = {f"p{i}": str(i) for i in range(n//2)}
    with pytest.raises(TypeError):
        deserialize_query_params(dep, params) # 7.03ms -> 6.86ms (2.39% faster)

def test_large_scale_extra_params():
    # Test many parameters, with extra irrelevant params
    def make_dep(n):
        code = "def dep(" + ", ".join(f"p{i}: int" for i in range(n)) + "):\n"
        code += "    return [" + ", ".join(f"p{i}" for i in range(n)) + "]\n"
        ns = {}
        exec(code, ns)
        return ns['dep']
    n = 100
    dep = make_dep(n)
    params = {f"p{i}": str(i) for i in range(n)}
    # Add 50 extra params
    params.update({f"extra{i}": "999" for i in range(50)})
    result, errors = deserialize_query_params(dep, params) # 13.9ms -> 13.6ms (2.32% 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 typing import Any, Callable, Dict, List, Optional, Tuple, TypeVar, Union
from urllib.parse import urlencode

# imports
import pytest
from fastapi import Query
from fastapi.datastructures import QueryParams
from fastapi.dependencies.utils import get_dependant, request_params_to_args
from titiler.core.utils import deserialize_query_params

T = TypeVar("T")
Errors = List[Any]
from titiler.core.utils import deserialize_query_params

# unit tests

# --- Basic Test Cases ---

def test_single_required_param():
    # Dependency with one required param
    def dep(a: int = Query(...)):
        return {"a": a}
    result, errors = deserialize_query_params(dep, {"a": "5"}) # 262μs -> 256μs (2.09% faster)

def test_multiple_required_params():
    def dep(a: int = Query(...), b: str = Query(...)):
        return {"a": a, "b": b}
    result, errors = deserialize_query_params(dep, {"a": "1", "b": "foo"}) # 366μs -> 366μs (0.040% faster)

def test_optional_param_with_default():
    def dep(a: int = Query(7)):
        return {"a": a}
    # param provided
    result, errors = deserialize_query_params(dep, {"a": "42"}) # 221μs -> 226μs (2.21% slower)
    # param not provided, should use default
    result, errors = deserialize_query_params(dep, {}) # 169μs -> 21.2μs (699% faster)

def test_param_with_list_type():
    def dep(a: List[int] = Query(...)):
        return {"a": a}
    result, errors = deserialize_query_params(dep, {"a": ["1", "2", "3"]}) # 289μs -> 286μs (1.05% faster)

def test_param_with_optional_type():
    def dep(a: Optional[int] = Query(None)):
        return {"a": a}
    # param provided
    result, errors = deserialize_query_params(dep, {"a": "10"}) # 302μs -> 301μs (0.227% faster)
    # param not provided
    result, errors = deserialize_query_params(dep, {}) # 224μs -> 23.5μs (853% faster)

# --- Edge Test Cases ---

def test_param_empty_string():
    def dep(a: str = Query(...)):
        return {"a": a}
    # param is empty string
    result, errors = deserialize_query_params(dep, {"a": ""}) # 267μs -> 265μs (0.918% faster)

def test_param_with_special_characters():
    def dep(a: str = Query(...)):
        return {"a": a}
    special = "a b&c=d?e"
    result, errors = deserialize_query_params(dep, {"a": special}) # 239μs -> 234μs (2.05% faster)

def test_multiple_values_for_list_param():
    def dep(a: List[str] = Query(...)):
        return {"a": a}
    # Query param a=foo&a=bar&a=baz
    result, errors = deserialize_query_params(dep, {"a": ["foo", "bar", "baz"]}) # 288μs -> 292μs (1.30% slower)

def test_param_with_none_value():
    def dep(a: Optional[int] = Query(None)):
        return {"a": a}
    # param explicitly set to None (should be interpreted as missing)
    result, errors = deserialize_query_params(dep, {"a": None}) # 316μs -> 315μs (0.370% faster)

def test_extra_param_ignored():
    def dep(a: int = Query(...)):
        return {"a": a}
    # extra param 'b' should be ignored
    result, errors = deserialize_query_params(dep, {"a": "7", "b": "should_ignore"}) # 225μs -> 227μs (1.01% slower)

def test_empty_params_dict():
    def dep(a: int = Query(42)):
        return {"a": a}
    result, errors = deserialize_query_params(dep, {}) # 220μs -> 218μs (0.774% faster)

def test_empty_queryparams_object():
    def dep(a: int = Query(99)):
        return {"a": a}
    result, errors = deserialize_query_params(dep, QueryParams()) # 213μs -> 213μs (0.188% slower)

# --- Large Scale Test Cases ---

To edit these changes git checkout codeflash/optimize-deserialize_query_params-mifo8grb and push.