Resolve list elements in parallel

Author: Cito

README.md

@@ -12,7 +12,7 @@ a query language for APIs created by Facebook.
 [![Python 3 Status](https://pyup.io/repos/github/graphql-python/graphql-core-next/python-3-shield.svg)](https://pyup.io/repos/github/graphql-python/graphql-core-next/)
 
 The current version 1.0.1 of GraphQL-core-next is up-to-date with GraphQL.js version
-14.0.2. All parts of the API are covered by an extensive test suite of currently 1616
+14.0.2. All parts of the API are covered by an extensive test suite of currently 1617
 unit tests.
 
 

graphql/execution/execute.py

@@ -425,7 +425,8 @@ def execute_fields(
         for "read" mode.
         """
         results = {}
-        awaitable_fields = []
+        awaitable_fields: List[str] = []
+        append_awaitable = awaitable_fields.append
         for response_name, field_nodes in fields.items():
             field_path = add_path(path, response_name)
             result = self.resolve_field(
@@ -434,7 +435,7 @@ def execute_fields(
             if result is not INVALID:
                 results[response_name] = result
                 if isawaitable(result):
-                    awaitable_fields.append(response_name)
+                    append_awaitable(response_name)
 
         #  If there are no coroutines, we can just return the object
         if not awaitable_fields:
@@ -805,9 +806,10 @@ def complete_list_value(
         # where the list contains no coroutine objects by avoiding creating
         # another coroutine object.
         item_type = return_type.of_type
-        is_async = False
+        awaitable_indices: List[int] = []
+        append_awaitable = awaitable_indices.append
         completed_results: List[Any] = []
-        append = completed_results.append
+        append_result = completed_results.append
         for index, item in enumerate(result):
             # No need to modify the info object containing the path,
             # since from here on it is not ever accessed by resolver functions.
@@ -816,20 +818,25 @@ def complete_list_value(
                 item_type, field_nodes, info, field_path, item
             )
 
-            if not is_async and isawaitable(completed_item):
-                is_async = True
-            append(completed_item)
+            if isawaitable(completed_item):
+                append_awaitable(index)
+            append_result(completed_item)
 
-        if is_async:
+        if not awaitable_indices:
+            return completed_results
 
-            async def get_completed_results():
-                return [
-                    await value if isawaitable(value) else value
-                    for value in completed_results
-                ]
-
-            return get_completed_results()
-        return completed_results
+        # noinspection PyShadowingNames
+        async def get_completed_results():
+            for index, result in zip(
+                awaitable_indices,
+                await gather(
+                    *(completed_results[index] for index in awaitable_indices)
+                ),
+            ):
+                completed_results[index] = result
+            return completed_results
+
+        return get_completed_results()
 
     @staticmethod
     def complete_leaf_value(return_type: GraphQLLeafType, result: Any) -> Any:

tests/execution/test_executor.py

@@ -831,6 +831,8 @@ def executes_ignoring_invalid_non_executable_definitions():
 
         assert execute(schema, query) == ({"foo": None}, None)
 
+
+def describe_customize_execution():
     def uses_a_custom_field_resolver():
         query = parse("{ foo }")
 
@@ -867,29 +869,31 @@ def resolve_field(self, parent_type, source, field_nodes, path):
             None,
         )
 
-    @mark.asyncio
-    async def resolve_fields_in_parallel():
-        class Barrier:
-            """Barrier that makes progress only after a certain number of waits."""
 
-            def __init__(self, number):
-                self.event = asyncio.Event()
-                self.number = number
+def describe_parallel_execution():
+    class Barrier:
+        """Barrier that makes progress only after a certain number of waits."""
+
+        def __init__(self, number: int) -> None:
+            self.event = asyncio.Event()
+            self.number = number
 
-            async def wait(self):
-                self.number -= 1
-                if not self.number:
-                    self.event.set()
-                return await self.event.wait()
+        async def wait(self) -> bool:
+            self.number -= 1
+            if not self.number:
+                self.event.set()
+            return await self.event.wait()
 
+    @mark.asyncio
+    async def resolve_fields_in_parallel():
         barrier = Barrier(2)
 
         async def resolve(*_args):
             return await barrier.wait()
 
         schema = GraphQLSchema(
             GraphQLObjectType(
-                "Object",
+                "Query",
                 {
                     "foo": GraphQLField(GraphQLBoolean, resolve=resolve),
                     "bar": GraphQLField(GraphQLBoolean, resolve=resolve),
@@ -898,6 +902,34 @@ async def resolve(*_args):
         )
 
         ast = parse("{foo, bar}")
+        # raises TimeoutError if not parallel
         result = await asyncio.wait_for(execute(schema, ast), 1.0)
 
         assert result == ({"foo": True, "bar": True}, None)
+
+    @mark.asyncio
+    async def resolve_list_in_parallel():
+        barrier = Barrier(2)
+
+        async def resolve(*_args):
+            return await barrier.wait()
+
+        async def resolve_list(*args):
+            return [resolve(*args), resolve(*args)]
+
+        schema = GraphQLSchema(
+            GraphQLObjectType(
+                "Query",
+                {
+                    "foo": GraphQLField(
+                        GraphQLList(GraphQLBoolean), resolve=resolve_list
+                    )
+                },
+            )
+        )
+
+        ast = parse("{foo}")
+        # raises TimeoutError if not parallel
+        result = await asyncio.wait_for(execute(schema, ast), 1.0)
+
+        assert result == ({"foo": [True, True]}, None)