From 9e4ce1ea0f0ad8b113443aa9fc01712e8b6a815b Mon Sep 17 00:00:00 2001 From: Gustav Bylund Date: Wed, 19 Feb 2025 22:22:49 +0100 Subject: [PATCH 1/3] test(dependency_cache): add test for repeated parsing --- tests/test_dependency_cache.py | 40 +++++++++++++++++++++++++++++++++- 1 file changed, 39 insertions(+), 1 deletion(-) diff --git a/tests/test_dependency_cache.py b/tests/test_dependency_cache.py index 08fb9b74f..cda3ec7b9 100644 --- a/tests/test_dependency_cache.py +++ b/tests/test_dependency_cache.py @@ -1,9 +1,27 @@ from fastapi import Depends, FastAPI, Security +from fastapi._compat import PYDANTIC_V2 from fastapi.testclient import TestClient +from pydantic import BaseModel app = FastAPI() -counter_holder = {"counter": 0} +counter_holder = {"counter": 0, "parsing_counter": 0} + +if PYDANTIC_V2: + from pydantic import model_validator + + decorator = model_validator(mode="before") +else: + from pydantic import root_validator + + decorator = root_validator + + +class Model(BaseModel): + @decorator + def __validate__(cls, _): + counter_holder["parsing_counter"] += 1 + return {} async def dep_counter(): @@ -15,6 +33,10 @@ async def super_dep(count: int = Depends(dep_counter)): return count +async def model_dep(model: Model) -> Model: + return model + + @app.get("/counter/") async def get_counter(count: int = Depends(dep_counter)): return {"counter": count} @@ -35,6 +57,15 @@ async def get_sub_counter_no_cache( return {"counter": count, "subcounter": subcount} +@app.post("/sub-model-parsing/") +async def get_double_model_parsing( + a: Model = Depends(model_dep), + b: Model = Depends(model_dep), +): + assert a is b + return {"parsing_counter": counter_holder["parsing_counter"]} + + @app.get("/scope-counter") async def get_scope_counter( count: int = Security(dep_counter), @@ -81,6 +112,13 @@ def test_sub_counter_no_cache(): assert response.json() == {"counter": 4, "subcounter": 3} +def test_sub_model_parsing_no_repeatable_parsing(): + counter_holder["parsing_counter"] = 0 + response = client.post("/sub-model-parsing/", json={}) + assert response.status_code == 200, response.text + assert response.json() == {"parsing_counter": 1} + + def test_security_cache(): counter_holder["counter"] = 0 response = client.get("/scope-counter/") From b31a1cd01b5f689808c40688b78c3935fb427692 Mon Sep 17 00:00:00 2001 From: Gustav Bylund Date: Thu, 21 Mar 2024 13:49:01 +0100 Subject: [PATCH 2/3] fix(dependencies): only set default dependency_cache if it is None This solves a bug where an empty dictionary would be reassigned. --- fastapi/dependencies/utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/fastapi/dependencies/utils.py b/fastapi/dependencies/utils.py index e2866b488..8a54d1ee7 100644 --- a/fastapi/dependencies/utils.py +++ b/fastapi/dependencies/utils.py @@ -587,7 +587,8 @@ async def solve_dependencies( response = Response() del response.headers["content-length"] response.status_code = None # type: ignore - dependency_cache = dependency_cache or {} + if dependency_cache is None: + dependency_cache = {} sub_dependant: Dependant for sub_dependant in dependant.dependencies: sub_dependant.call = cast(Callable[..., Any], sub_dependant.call) @@ -624,7 +625,6 @@ async def solve_dependencies( embed_body_fields=embed_body_fields, ) background_tasks = solved_result.background_tasks - dependency_cache.update(solved_result.dependency_cache) if solved_result.errors: errors.extend(solved_result.errors) continue From 0821c80554223dfbeb610061578a811679e001fa Mon Sep 17 00:00:00 2001 From: Gustav Bylund Date: Wed, 20 Mar 2024 18:30:37 +0100 Subject: [PATCH 3/3] perf(dependencies): skip doing any work when sub dependant is already cached --- fastapi/dependencies/utils.py | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/fastapi/dependencies/utils.py b/fastapi/dependencies/utils.py index 8a54d1ee7..fc5e8c60e 100644 --- a/fastapi/dependencies/utils.py +++ b/fastapi/dependencies/utils.py @@ -595,6 +595,17 @@ async def solve_dependencies( sub_dependant.cache_key = cast( Tuple[Callable[..., Any], Tuple[str]], sub_dependant.cache_key ) + + if sub_dependant.use_cache: + # Use a unique object to compare against in case the cached value is None + cache_miss = object() + cached_value = dependency_cache.get(sub_dependant.cache_key, cache_miss) + # If the sub dependant is already cached, skip doing any more work + if cached_value is not cache_miss: + if sub_dependant.name is not None: + values[sub_dependant.name] = cached_value + continue + call = sub_dependant.call use_sub_dependant = sub_dependant if ( @@ -628,9 +639,7 @@ async def solve_dependencies( if solved_result.errors: errors.extend(solved_result.errors) continue - if sub_dependant.use_cache and sub_dependant.cache_key in dependency_cache: - solved = dependency_cache[sub_dependant.cache_key] - elif is_gen_callable(call) or is_async_gen_callable(call): + if is_gen_callable(call) or is_async_gen_callable(call): solved = await solve_generator( call=call, stack=async_exit_stack, sub_values=solved_result.values )