Fixed threading.Lock held across await in async DI resolver

Author: mr-fatalyst

fastopenapi/core/dependency_resolver.py

@@ -472,35 +472,20 @@ async def _execute_dependency_function_async(
         cache_key = self._make_cache_key(dependency_func, request_data)
         request_cache = self._get_request_cache(request_data)
 
-        # First check (without lock)
         hit, value = self._try_get_cached(cache_key, request_cache)
         if hit:
             return value
 
-        # Get or create lock for this function
-        func_id = id(dependency_func)
-        with self._execution_locks_lock:
-            if func_id not in self._execution_locks:
-                self._execution_locks[func_id] = threading.Lock()
-            func_lock = self._execution_locks[func_id]
-
-        # Synchronize execution per function
-        with func_lock:
-            # Second check (double-checked locking pattern)
-            hit, value = self._try_get_cached(cache_key, request_cache)
-            if hit:
-                return value
-
-            # Guard against circular dependencies
-            with self._resolving_guard(request_cache, dependency_func, param_name):
-                sub_dependencies = await self._resolve_sub_dependencies_async(
-                    dependency_func, request_data, security_scopes
-                )
-                result = await self._call_dependency_async(
-                    dependency_func, sub_dependencies or {}, request_data
-                )
-                self._cache_result(cache_key, result, request_cache)
-                return result
+        # Guard against circular dependencies
+        with self._resolving_guard(request_cache, dependency_func, param_name):
+            sub_dependencies = await self._resolve_sub_dependencies_async(
+                dependency_func, request_data, security_scopes
+            )
+            result = await self._call_dependency_async(
+                dependency_func, sub_dependencies or {}, request_data
+            )
+            self._cache_result(cache_key, result, request_cache)
+            return result
 
     async def _call_dependency_async(
         self,

tests/core/test_dependency_resolver.py

@@ -1411,47 +1411,6 @@ def endpoint(s: str = Depends(sync_dep), a: str = Depends(async_dep)):
         )
         assert result == {"s": "sync", "a": "async"}
 
-    @pytest.mark.asyncio
-    async def test_async_double_checked_locking_second_check_hit(self):
-        """Test second cache check (inside lock) finds value and returns it"""
-
-        async def test_dep():
-            return "should_not_execute"
-
-        # Initialize cache manually
-        with self.resolver._request_cache_lock:
-            self.resolver._request_cache[self.request_data] = {
-                "resolved": {},
-                "resolving": set(),
-            }
-
-        self.resolver._make_cache_key(test_dep, self.request_data)
-        self.resolver._get_request_cache(self.request_data)
-
-        # Mock _try_get_cached to return miss first, then hit
-        call_count = {"count": 0}
-
-        def mock_try_get_cached(key, cache):
-            call_count["count"] += 1
-            if call_count["count"] == 1:
-                # First check (before lock) - miss
-                return (False, None)
-            else:
-                # Second check (inside lock) - HIT
-                return (True, "from_second_check")
-
-        with patch.object(
-            self.resolver, "_try_get_cached", side_effect=mock_try_get_cached
-        ):
-            # Call the internal method directly to avoid outer cleanup
-            result = await self.resolver._execute_dependency_function_async(
-                test_dep, self.request_data, "dep"
-            )
-
-            # Should return value from second check without executing function
-            assert result == "from_second_check"
-            assert call_count["count"] == 2  # Called twice
-
     @pytest.mark.asyncio
     async def test_async_cleanup_when_cache_already_deleted(self):
         """Test finally cleanup when request_data already removed from cache"""