Improved experimental execution speed with simulated Ordered dicts

Author: syrusakbary

graphql/error/tests/test_base.py

@@ -47,4 +47,14 @@ def resolver(context, *_):
         ('resolve_or_error', 'return executor.execute(resolve_fn, source, args, context, info)'),
         ('execute', 'return fn(*args, **kwargs)'), ('resolver', "raise Exception('Failed')")
     ]
+    # assert formatted_tb == [
+    #     ('test_reraise', 'result.errors[0].reraise()'),
+    #     ('reraise', 'six.reraise(type(self), self, self.stack)'),
+    #     ('on_complete_resolver', 'result = __resolver(*args, **kwargs)'),
+    #     # ('reraise', 'raise value.with_traceback(tb)'),
+    #     # ('resolve_or_error', 'return executor.execute(resolve_fn, source, args, context, info)'),
+    #     # ('execute', 'return fn(*args, **kwargs)'),
+    #     ('resolver', "raise Exception('Failed')")
+    # ]
+
     assert str(exc_info.value) == 'Failed'

graphql/execution/executors/utils.py

@@ -1,6 +1,6 @@
 def process(p, f, args, kwargs):
     try:
         val = f(*args, **kwargs)
-        p.fulfill(val)
+        p.do_resolve(val)
     except Exception as e:
-        p.reject(e)
+        p.do_reject(e)

graphql/execution/experimental/fragment.py

@@ -1,6 +1,6 @@
 import functools
 
-from promise import Promise, promise_for_dict
+from promise import Promise, is_thenable, promise_for_dict
 
 from ...pyutils.cached_property import cached_property
 from ...pyutils.default_ordered_dict import DefaultOrderedDict
@@ -10,10 +10,7 @@
 from ..base import ResolveInfo, Undefined, collect_fields, get_field_def
 from ..values import get_argument_values
 from ...error import GraphQLError
-
-
-def is_promise(obj):
-    return isinstance(obj, Promise)
+from .utils import imap, normal_map
 
 
 def get_base_type(type):
@@ -78,7 +75,20 @@ def get_resolvers(context, type, field_asts):
             field_ast.arguments,
             context and context.variable_values
         )
-        yield (response_name, resolver, args, context and context.context_value, info)
+        yield (response_name, Field(resolver, args, context and context.context_value, info))
+
+
+class Field(object):
+    __slots__ = ('fn', 'args', 'context', 'info')
+
+    def __init__(self, fn, args, context, info):
+        self.fn = fn
+        self.args = args
+        self.context = context
+        self.info = info
+
+    def execute(self, root):
+        return self.fn(root, self.args, self.context, self.info)
 
 
 class Fragment(object):
@@ -97,6 +107,22 @@ def partial_resolvers(self):
             self.field_asts
         ))
 
+    @cached_property
+    def fragment_container(self):
+        fields = zip(*self.partial_resolvers)[0]
+        class FragmentInstance(dict):
+            # def __init__(self):
+                # self.fields = fields
+            # _fields = ('c','b','a')
+            set = dict.__setitem__
+            # def set(self, name, value):
+            #     self[name] = value
+
+            def __iter__(self):
+                return iter(fields)
+
+        return FragmentInstance
+
     def have_type(self, root):
         return not self.type.is_type_of or self.type.is_type_of(root, self.context.context_value, self.info)
 
@@ -109,18 +135,18 @@ def resolve(self, root):
 
         contains_promise = False
 
-        final_results = OrderedDict()
+        final_results = self.fragment_container()
         # return OrderedDict(
         #     ((field_name, field_resolver(root, field_args, context, info))
         #         for field_name, field_resolver, field_args, context, info in self.partial_resolvers)
         # )
-        for response_name, field_resolver, field_args, context, info in self.partial_resolvers:
+        for response_name, field_resolver in self.partial_resolvers:
 
-            result = field_resolver(root, field_args, context, info)
+            result = field_resolver.execute(root)
             if result is Undefined:
                 continue
 
-            if not contains_promise and is_promise(result):
+            if not contains_promise and is_thenable(result):
                 contains_promise = True
 
             final_results[response_name] = result
@@ -136,14 +162,14 @@ def resolve(self, root):
 
     def resolve_serially(self, root):
         def execute_field_callback(results, resolver):
-            response_name, field_resolver, field_args, context, info = resolver
+            response_name, field_resolver = resolver
 
-            result = field_resolver(root, field_args, context, info)
+            result = field_resolver.execute(root)
 
             if result is Undefined:
                 return results
 
-            if is_promise(result):
+            if is_thenable(result):
                 def collect_result(resolved_result):
                     results[response_name] = resolved_result
                     return results
@@ -156,7 +182,7 @@ def collect_result(resolved_result):
         def execute_field(prev_promise, resolver):
             return prev_promise.then(lambda results: execute_field_callback(results, resolver))
 
-        return functools.reduce(execute_field, self.partial_resolvers, Promise.resolve(OrderedDict()))
+        return functools.reduce(execute_field, self.partial_resolvers, Promise.resolve(self.fragment_container()))
 
     def __eq__(self, other):
         return isinstance(other, Fragment) and (
@@ -180,6 +206,12 @@ def __init__(self, abstract_type, field_asts, context=None, info=None):
     def possible_types(self):
         return self.context.schema.get_possible_types(self.abstract_type)
 
+    @cached_property
+    def possible_types_with_is_type_of(self):
+        return [
+            (type, type.is_type_of) for type in self.possible_types if callable(type.is_type_of)
+        ]
+
     def get_fragment(self, type):
         if isinstance(type, str):
             type = self.context.schema.get_type(type)
@@ -194,6 +226,7 @@ def get_fragment(self, type):
                 self.context,
                 self.info
             )
+
         return self._fragments[type]
 
     def resolve_type(self, result):
@@ -202,10 +235,10 @@ def resolve_type(self, result):
 
         if return_type.resolve_type:
             return return_type.resolve_type(result, context, self.info)
-        else:
-            for type in self.possible_types:
-                if callable(type.is_type_of) and type.is_type_of(result, context, self.info):
-                    return type
+
+        for type, is_type_of in self.possible_types_with_is_type_of:
+            if is_type_of(result, context, self.info):
+                return type
 
     def resolve(self, root):
         _type = self.resolve_type(root)

graphql/execution/experimental/resolver.py

@@ -12,9 +12,6 @@
 from ...execution import executor
 from .utils import imap, normal_map
 
-def is_promise(value):
-    return isinstance(value, Promise)
-
 
 def on_complete_resolver(on_error, __func, exe_context, info, __resolver, *args, **kwargs):
     try:
@@ -46,7 +43,7 @@ def complete_list_value(inner_resolver, exe_context, info, on_error, result):
 
     completed_results = normal_map(inner_resolver, result)
 
-    if not any(imap(is_promise, completed_results)):
+    if not any(imap(is_thenable, completed_results)):
         return completed_results
 
     return Promise.all(completed_results).catch(on_error)
@@ -72,7 +69,7 @@ def complete_object_value(fragment_resolve, exe_context, on_error, result):
         return None
 
     result = fragment_resolve(result)
-    if is_promise(result):
+    if is_thenable(result):
         return result.catch(on_error)
     return result
 

graphql/pyutils/contain_subset.py

@@ -4,7 +4,10 @@
 def contain_subset(expected, actual):
     t_actual = type(actual)
     t_expected = type(expected)
-    if not(issubclass(t_actual, t_expected) or issubclass(t_expected, t_actual)):
+    actual_is_dict = issubclass(t_actual, dict)
+    expected_is_dict = issubclass(t_expected, dict)
+    both_dicts = actual_is_dict and expected_is_dict
+    if not(both_dicts) and not(issubclass(t_actual, t_expected) or issubclass(t_expected, t_actual)):
         return False
     if not isinstance(expected, obj) or expected is None:
         return expected == actual