AsyncioExecutionMiddleware implementation. Yes, it's that simple!

Author: jhgg

graphql/core/execution/middlewares/AsyncioExecutionMiddleware.py

@@ -0,0 +1,37 @@
+from asyncio import Future, coroutine, iscoroutine, ensure_future
+from graphql.core.defer import Deferred
+
+
+def process_future_result(deferred):
+    def handle_future_result(future: Future):
+        exception = future.exception()
+        if exception:
+            deferred.errback(exception)
+
+        else:
+            deferred.callback(future.result())
+
+    return handle_future_result
+
+
+class AsyncioExecutionMiddleware(object):
+    def run_resolve_fn(self, resolver):
+        result = resolver()
+        if isinstance(result, Future) or iscoroutine(result):
+            future = ensure_future(result)
+            d = Deferred()
+            future.add_done_callback(process_future_result(d))
+            return d
+
+        return result
+
+    def execution_result(self, executor):
+        future = Future()
+        result = executor()
+        assert isinstance(result, Deferred), 'Another middleware has converted the execution result ' \
+                                             'away from a Deferred.'
+
+        result.add_callback(future.set_result)
+        result.add_errback(future.set_exception)
+
+        return future

tests_py35/core_execution/__init__.py

@@ -0,0 +1 @@
+__author__ = 'jake'

tests_py35/core_execution/test_asyncio_executor.py

@@ -0,0 +1,41 @@
+from graphql.core.execution.parallel_execution import Executor
+from graphql.core.execution.middlewares.AsyncioExecutionMiddleware import AsyncioExecutionMiddleware
+from graphql.core.type import (
+    GraphQLSchema,
+    GraphQLObjectType,
+    GraphQLField,
+    GraphQLString
+)
+import functools
+import asyncio
+
+
+def run_until_complete(fun):
+    @functools.wraps(fun)
+    def wrapper(*args, **kwargs):
+        coro = fun(*args, **kwargs)
+        return asyncio.get_event_loop().run_until_complete(coro)
+    return wrapper
+
+
+@run_until_complete
+async def test_asyncio_py35_executor():
+    doc = 'query Example { a, b }'
+
+    async def resolver(context, *_):
+        await asyncio.sleep(0.001)
+        return 'hey'
+
+    async def resolver_2(context, *_):
+        await asyncio.sleep(0.003)
+        return 'hey2'
+
+    Type = GraphQLObjectType('Type', {
+        'a': GraphQLField(GraphQLString, resolver=resolver),
+        'b': GraphQLField(GraphQLString, resolver=resolver_2)
+    })
+
+    executor = Executor(GraphQLSchema(Type), [AsyncioExecutionMiddleware()])
+    result = await executor.execute(doc)
+    assert not result.errors
+    assert result.data == {'a': 'hey', 'b': 'hey2'}