Improved experimental executor code

Author: syrusakbary

graphql/execution/experimental/executor.py

@@ -1,30 +1,26 @@
-import collections
-import functools
 import logging
-import sys
 
 from promise import Promise, promise_for_dict, promisify
 
 from ...error import GraphQLError, GraphQLLocatedError
 from ...pyutils.default_ordered_dict import DefaultOrderedDict
 from ...pyutils.ordereddict import OrderedDict
 from ...type import (GraphQLEnumType, GraphQLInterfaceType, GraphQLList,
-                    GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
-                    GraphQLSchema, GraphQLUnionType)
+                     GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
+                     GraphQLSchema, GraphQLUnionType)
 from ..base import (ExecutionContext, ExecutionResult, ResolveInfo, Undefined,
-                   collect_fields, default_resolve_fn, get_field_def,
-                   get_operation_root_type)
+                    collect_fields, default_resolve_fn, get_field_def,
+                    get_operation_root_type)
 from ..executors.sync import SyncExecutor
 from ..middleware import MiddlewareManager
-
-from .resolver import type_resolver
 from .fragment import Fragment
+from .resolver import type_resolver
 
 logger = logging.getLogger(__name__)
 
 
 def is_promise(obj):
-    return type(obj) == Promise
+    return isinstance(obj, Promise)
 
 
 def execute(schema, document_ast, root_value=None, context_value=None,

graphql/execution/experimental/fragment.py

@@ -1,17 +1,15 @@
-from promise import promise_for_dict, Promise
-
 import functools
-from functools import partial
-from ...pyutils.cached_property import cached_property
-from ..values import get_argument_values, get_variable_values
-from ..base import collect_fields, ResolveInfo, Undefined, get_field_def
-from ..executor import is_promise
-
-from ...pyutils.ordereddict import OrderedDict
-from ...pyutils.default_ordered_dict import DefaultOrderedDict
 
+from promise import Promise, promise_for_dict
 
-from ...type import GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLInterfaceType, GraphQLUnionType
+from ...pyutils.cached_property import cached_property
+from ...pyutils.default_ordered_dict import DefaultOrderedDict
+from ...pyutils.ordereddict import OrderedDict
+from ...type import (GraphQLInterfaceType, GraphQLList, GraphQLNonNull,
+                     GraphQLObjectType, GraphQLUnionType)
+from ..base import ResolveInfo, Undefined, collect_fields, get_field_def
+from ..executor import is_promise
+from ..values import get_argument_values, get_variable_values
 
 
 def get_base_type(type):
@@ -74,6 +72,7 @@ def get_resolvers(context, type, selection_set):
 
 
 class Fragment(object):
+
     def __init__(self, type, selection_set, context=None):
         self.type = type
         self.selection_set = selection_set
@@ -147,6 +146,7 @@ def __eq__(self, other):
 
 
 class AbstractFragment(object):
+
     def __init__(self, abstract_type, selection_set, context=None, info=None):
         self.abstract_type = abstract_type
         self.selection_set = selection_set

graphql/execution/experimental/resolver.py

@@ -1,21 +1,19 @@
-import itertools
-import sys
-import traceback
 import collections
+import itertools
 from functools import partial
 
-from ..base import default_resolve_fn
+from promise import Promise
+
 from ...error import GraphQLError, GraphQLLocatedError
 from ...type import (GraphQLEnumType, GraphQLInterfaceType, GraphQLList,
                      GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
                      GraphQLSchema, GraphQLUnionType)
+from ..base import default_resolve_fn
 from .fragment import Fragment
 
-from promise import Promise
-
 
 def is_promise(value):
-    return type(value) == Promise
+    return isinstance(value, Promise)
 
 
 def on_complete_resolver(on_error, __func, exe_context, info, __resolver, *args, **kwargs):
@@ -24,11 +22,10 @@ def on_complete_resolver(on_error, __func, exe_context, info, __resolver, *args,
         if is_promise(result):
             return result.then(__func).catch(on_error)
         return __func(result)
-    except Exception, e:
+    except Exception as e:
         return on_error(e)
 
 
-
 def complete_list_value(inner_resolver, exe_context, info, on_error, result):
     if result is None:
         return None
@@ -71,7 +68,8 @@ def complete_object_value(fragment_resolve, exe_context, on_error, result):
 
 
 def field_resolver(field, fragment=None, exe_context=None, info=None):
-    return type_resolver(field.type, field.resolver or default_resolve_fn, fragment, exe_context, info, catch_error=True)
+    return type_resolver(field.type, field.resolver or default_resolve_fn,
+                         fragment, exe_context, info, catch_error=True)
 
 
 def type_resolver(return_type, resolver, fragment=None, exe_context=None, info=None, catch_error=False):
@@ -107,12 +105,16 @@ def on_error(exe_context, info, catch_error, e):
 
 def type_resolver_fragment(return_type, resolver, fragment, exe_context, info, catch_error):
     on_complete_type_error = partial(on_error, exe_context, info, catch_error)
-    complete_object_value_resolve = partial(complete_object_value, fragment.resolve, exe_context, on_complete_type_error)
+    complete_object_value_resolve = partial(
+        complete_object_value,
+        fragment.resolve,
+        exe_context,
+        on_complete_type_error)
     on_resolve_error = partial(on_error, exe_context, info, catch_error)
     return partial(on_complete_resolver, on_resolve_error, complete_object_value_resolve, exe_context, info, resolver)
 
 
-def type_resolver_non_null(return_type, resolver, fragment, exe_context, info): # no catch_error
+def type_resolver_non_null(return_type, resolver, fragment, exe_context, info):  # no catch_error
     resolver = type_resolver(return_type.of_type, resolver, fragment, exe_context, info)
     nonnull_complete = partial(complete_nonnull_value, exe_context, info)
     on_resolve_error = partial(on_error, exe_context, info, False)

graphql/execution/experimental/tests/test_benchmark.py

@@ -1,29 +1,38 @@
 import pytest
 
-from ....language import ast
-from ....type import (GraphQLEnumType, GraphQLInterfaceType, GraphQLList,
-                      GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
-                      GraphQLSchema, GraphQLUnionType, GraphQLString, GraphQLInt, GraphQLField)
-from ..resolver import type_resolver, Fragment
-
 from promise import Promise
 
+from ....language import ast
+from ....type import (GraphQLEnumType, GraphQLField, GraphQLInt,
+                      GraphQLInterfaceType, GraphQLList, GraphQLNonNull,
+                      GraphQLObjectType, GraphQLScalarType, GraphQLSchema,
+                      GraphQLString, GraphQLUnionType)
+from ..resolver import Fragment, type_resolver
 
 SIZE = 10000
 
+
 def test_querybuilder_big_list_of_ints(benchmark):
     big_int_list = [x for x in range(SIZE)]
 
     resolver = type_resolver(GraphQLList(GraphQLInt), lambda: big_int_list)
     result = benchmark(resolver)
-    
+
     assert result == big_int_list
 
 
 def test_querybuilder_big_list_of_nested_ints(benchmark):
     big_int_list = [x for x in range(SIZE)]
 
-    Node = GraphQLObjectType('Node', fields={'id': GraphQLField(GraphQLInt, resolver=lambda obj, args, context, info: obj)})
+    Node = GraphQLObjectType(
+        'Node',
+        fields={
+            'id': GraphQLField(
+                GraphQLInt,
+                resolver=lambda obj,
+                args,
+                context,
+                info: obj)})
     selection_set = ast.SelectionSet(selections=[
         ast.Field(
             alias=None,
@@ -43,13 +52,12 @@ def test_querybuilder_big_list_of_nested_ints(benchmark):
     } for n in big_int_list]
 
 
-
 def test_querybuilder_big_list_of_objecttypes_with_two_int_fields(benchmark):
     big_int_list = [x for x in range(SIZE)]
 
     Node = GraphQLObjectType('Node', fields={
         'id': GraphQLField(GraphQLInt, resolver=lambda obj, args, context, info: obj),
-        'ida': GraphQLField(GraphQLInt, resolver=lambda obj, args, context, info: obj*2)
+        'ida': GraphQLField(GraphQLInt, resolver=lambda obj, args, context, info: obj * 2)
     })
     selection_set = ast.SelectionSet(selections=[
         ast.Field(
@@ -74,15 +82,20 @@ def test_querybuilder_big_list_of_objecttypes_with_two_int_fields(benchmark):
 
     assert resolved == [{
         'id': n,
-        'ida': n*2
+        'ida': n * 2
     } for n in big_int_list]
 
 
-
 def test_querybuilder_big_list_of_objecttypes_with_one_int_field(benchmark):
     big_int_list = [x for x in range(SIZE)]
     Node = GraphQLObjectType('Node', fields={'id': GraphQLField(GraphQLInt, resolver=lambda obj, *_, **__: obj)})
-    Query = GraphQLObjectType('Query', fields={'nodes': GraphQLField(GraphQLList(Node), resolver=lambda *_, **__: big_int_list)})
+    Query = GraphQLObjectType(
+        'Query',
+        fields={
+            'nodes': GraphQLField(
+                GraphQLList(Node),
+                resolver=lambda *_,
+                **__: big_int_list)})
     node_selection_set = ast.SelectionSet(selections=[
         ast.Field(
             name=ast.Name(value='id'),

graphql/execution/experimental/tests/test_directives.py

@@ -1,6 +1,7 @@
 from graphql.language.parser import parse
 from graphql.type import (GraphQLField, GraphQLObjectType, GraphQLSchema,
                           GraphQLString)
+
 from ..executor import execute
 
 schema = GraphQLSchema(

graphql/execution/experimental/tests/test_executor.py

@@ -1,19 +1,23 @@
-import pytest
 from functools import partial
 
+import pytest
+
+from promise import Promise
+
 from ....language import ast
-from ....type import (GraphQLEnumType, GraphQLInterfaceType, GraphQLList,
-                      GraphQLNonNull, GraphQLObjectType, GraphQLScalarType, GraphQLBoolean,
-                      GraphQLSchema, GraphQLUnionType, GraphQLString, GraphQLInt, GraphQLField)
-from ..resolver import type_resolver
-from ..fragment import Fragment
-from ...base import ExecutionContext
 from ....language.parser import parse
-
+from ....type import (GraphQLBoolean, GraphQLEnumType, GraphQLField,
+                      GraphQLInt, GraphQLInterfaceType, GraphQLList,
+                      GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
+                      GraphQLSchema, GraphQLString, GraphQLUnionType)
+from ...base import ExecutionContext
 from ..executor import execute
+from ..fragment import Fragment
+from ..resolver import type_resolver
+
+
 # from ...executor import execute
 
-from promise import Promise
 
 
 def test_fragment_resolver_abstract(benchmark):
@@ -22,9 +26,15 @@ def test_fragment_resolver_abstract(benchmark):
     Node = GraphQLInterfaceType('Node', fields={'id': GraphQLField(GraphQLInt)})
     Person = GraphQLObjectType('Person', interfaces=(Node, ), is_type_of=lambda *_, **__: True, fields={
         'id': GraphQLField(GraphQLInt, resolver=lambda obj, *_, **__: obj),
-        'name': GraphQLField(GraphQLString, resolver=lambda obj, *_, **__: "name:"+str(obj))
+        'name': GraphQLField(GraphQLString, resolver=lambda obj, *_, **__: "name:" + str(obj))
     })
-    Query = GraphQLObjectType('Query', fields={'nodes': GraphQLField(GraphQLList(Node), resolver=lambda *_, **__: all_slots)})
+    Query = GraphQLObjectType(
+        'Query',
+        fields={
+            'nodes': GraphQLField(
+                GraphQLList(Node),
+                resolver=lambda *_,
+                **__: all_slots)})
 
     document_ast = parse('''query {
         nodes {
@@ -43,7 +53,7 @@ def test_fragment_resolver_abstract(benchmark):
     assert resolved.data == {
         'nodes': [{
             'id': x,
-            'name': 'name:'+str(x)
+            'name': 'name:' + str(x)
         } for x in all_slots]
     }
 

graphql/execution/experimental/tests/test_fragment.py

@@ -1,16 +1,16 @@
 import pytest
 
+from promise import Promise
+
 from ....language import ast
-from ....type import (GraphQLEnumType, GraphQLInterfaceType, GraphQLList,
-                      GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
-                      GraphQLSchema, GraphQLUnionType, GraphQLString, GraphQLInt, GraphQLField)
-from ..resolver import type_resolver
-from ..fragment import Fragment
-from ...base import ExecutionContext
 from ....language.parser import parse
-
-
-from promise import Promise
+from ....type import (GraphQLEnumType, GraphQLField, GraphQLInt,
+                      GraphQLInterfaceType, GraphQLList, GraphQLNonNull,
+                      GraphQLObjectType, GraphQLScalarType, GraphQLSchema,
+                      GraphQLString, GraphQLUnionType)
+from ...base import ExecutionContext
+from ..fragment import Fragment
+from ..resolver import type_resolver
 
 
 def test_fragment_equal():
@@ -36,7 +36,7 @@ def test_fragment_equal():
 
 
 def test_fragment_resolver():
-    Node = GraphQLObjectType('Node', fields={'id': GraphQLField(GraphQLInt, resolver=lambda obj, *_, **__: obj*2)})
+    Node = GraphQLObjectType('Node', fields={'id': GraphQLField(GraphQLInt, resolver=lambda obj, *_, **__: obj * 2)})
     selection_set = ast.SelectionSet(selections=[
         ast.Field(
             name=ast.Name(value='id'),
@@ -91,7 +91,18 @@ def test_fragment_resolver_nested():
 
 def test_fragment_resolver_abstract():
     Node = GraphQLInterfaceType('Node', fields={'id': GraphQLField(GraphQLInt)})
-    Person = GraphQLObjectType('Person', interfaces=(Node, ), is_type_of=lambda *_: True, fields={'id': GraphQLField(GraphQLInt, resolver=lambda obj, *_, **__: obj)})
+    Person = GraphQLObjectType(
+        'Person',
+        interfaces=(
+            Node,
+        ),
+        is_type_of=lambda *_: True,
+        fields={
+            'id': GraphQLField(
+                GraphQLInt,
+                resolver=lambda obj,
+                *_,
+                **__: obj)})
     Query = GraphQLObjectType('Query', fields={'node': GraphQLField(Node, resolver=lambda *_, **__: 1)})
     node_selection_set = ast.SelectionSet(selections=[
         ast.Field(
@@ -141,7 +152,13 @@ def test_fragment_resolver_abstract():
 
 def test_fragment_resolver_nested_list():
     Node = GraphQLObjectType('Node', fields={'id': GraphQLField(GraphQLInt, resolver=lambda obj, *_, **__: obj)})
-    Query = GraphQLObjectType('Query', fields={'nodes': GraphQLField(GraphQLList(Node), resolver=lambda *_, **__: range(3))})
+    Query = GraphQLObjectType(
+        'Query',
+        fields={
+            'nodes': GraphQLField(
+                GraphQLList(Node),
+                resolver=lambda *_,
+                **__: range(3))})
     node_selection_set = ast.SelectionSet(selections=[
         ast.Field(
             name=ast.Name(value='id'),
@@ -177,4 +194,4 @@ def test_fragment_resolver_nested_list():
 # 	('author', AuthorFragment(
 # 		('name', str(resolve_author()))
 # 	))
-# )
+# )

graphql/execution/experimental/tests/test_mutations.py

@@ -1,9 +1,10 @@
-from ..executor import execute
 from graphql.language.parser import parse
 from graphql.type import (GraphQLArgument, GraphQLField, GraphQLInt,
                           GraphQLList, GraphQLObjectType, GraphQLSchema,
                           GraphQLString)
 
+from ..executor import execute
+
 
 class NumberHolder(object):