Merge dedc351656 into 8032e21418

fastapi/dependencies/utils.py

@@ -587,13 +587,25 @@ 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)
         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 (
@@ -624,13 +636,10 @@ 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
-        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
             )

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/")