Improved code with PEP8, Flake8, isort

Author: syrusakbary

graphql/execution/__init__.py

@@ -21,5 +21,8 @@
 from .execute import execute as _execute
 from .base import ExecutionResult
 
+
 def execute(schema, root, ast, operation_name='', args=None):
     return _execute(schema, ast, root, variable_values=args, operation_name=operation_name)
+
+__all__ = ['execute', 'ExecutionResult']

graphql/execution/base.py

@@ -251,7 +251,8 @@ def get_field_entry_key(node):
 
 class ResolveInfo(object):
 
-    def __init__(self, field_name, field_asts, return_type, parent_type, schema, fragments, root_value, operation, variable_values):
+    def __init__(self, field_name, field_asts, return_type, parent_type,
+                 schema, fragments, root_value, operation, variable_values):
         self.field_name = field_name
         self.field_asts = field_asts
         self.return_type = return_type

graphql/execution/execute.py

@@ -2,26 +2,24 @@
 import functools
 
 from ..error import GraphQLError
-from ..language import ast
-from ..language.parser import parse
-from ..language.source import Source
+from ..pyutils.aplus import Promise, is_thenable, promise_for_dict, promisify
 from ..pyutils.default_ordered_dict import DefaultOrderedDict
-from ..pyutils.aplus import Promise, is_thenable, promisify, promise_for_dict
-from ..pyutils.defer import (Deferred, DeferredDict, DeferredList, defer,
-                             succeed)
 from ..type import (GraphQLEnumType, GraphQLInterfaceType, GraphQLList,
                     GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
-                    GraphQLUnionType, GraphQLSchema)
-from ..validation import validate
+                    GraphQLSchema, GraphQLUnionType)
 from .base import (ExecutionContext, ExecutionResult, ResolveInfo, Undefined,
                    collect_fields, default_resolve_fn, get_field_def,
                    get_operation_root_type)
 from .executors.sync import SyncExecutor
 
 
-def execute(schema, document_ast, root_value=None, context_value=None, variable_values=None, operation_name=None, executor=None):
+def execute(schema, document_ast, root_value=None, context_value=None,
+            variable_values=None, operation_name=None, executor=None):
     assert schema, 'Must provide schema'
-    assert isinstance(schema, GraphQLSchema), 'Schema must be an instance of GraphQLSchema. Also ensure that there are not multiple versions of GraphQL installed in your node_modules directory.'
+    assert isinstance(schema, GraphQLSchema), (
+        'Schema must be an instance of GraphQLSchema. Also ensure that there are ' +
+        'not multiple versions of GraphQL installed in your node_modules directory.'
+    )
 
     if executor is None:
         executor = SyncExecutor()
@@ -51,7 +49,6 @@ def on_resolve(data):
     return p.value
 
 
-
 def execute_operation(exe_context, operation, root_value):
     type = get_operation_root_type(exe_context.schema, operation)
     fields = collect_fields(
@@ -89,38 +86,13 @@ def collect_result(resolved_result):
 
         results[response_name] = result
         return results
+
     def execute_field(prev_promise, response_name):
         return prev_promise.then(lambda results: execute_field_callback(results, response_name))
 
     return functools.reduce(execute_field, fields.keys(), Promise.resolve(collections.OrderedDict()))
 
 
-# def execute_fields_serially(exe_context, parent_type, source_value, fields):
-#     final_results = collections.OrderedDict()
-
-#     prev_promise = Promise.resolve(collections.OrderedDict())
-
-#     def on_promise(results, response_name, field_asts):
-#         result = resolve_field(exe_context, parent_type, source_value, field_asts)
-#         if result is Undefined:
-#             return results
-
-#         if is_thenable(result):
-#             def collect_result(resolved_result):
-#                 results[response_name] = resolved_result
-#                 return results
-
-#             return promisify(result).then(collect_result)
-
-#         results[response_name] = result
-#         return results
-
-#     for response_name, field_asts in fields.items():
-#         prev_promise = prev_promise.then(lambda results: on_promise(results, response_name, field_asts))
-
-#     return prev_promise
-
-
 def execute_fields(exe_context, parent_type, source_value, fields):
     contains_promise = False
 
@@ -166,8 +138,8 @@ def resolve_field(exe_context, parent_type, source, field_asts):
         schema=exe_context.schema,
         fragments=exe_context.fragments,
         root_value=exe_context.root_value,
-        operation= exe_context.operation,
-        variable_values= exe_context.variable_values,
+        operation=exe_context.operation,
+        variable_values=exe_context.variable_values,
     )
 
     result = resolve_or_error(resolve_fn, source, args, exe_context, info)
@@ -302,7 +274,6 @@ def complete_list_value(exe_context, return_type, field_asts, info, result):
     return Promise.all(completed_results) if contains_promise else completed_results
 
 
-
 def complete_leaf_value(return_type, result):
     """
     Complete a Scalar or Enum by serializing to a valid value, returning null if serialization is not possible.

graphql/execution/executors/asyncio.py

@@ -1,6 +1,7 @@
 from __future__ import absolute_import
 
-from asyncio import Future, ensure_future, iscoroutine, get_event_loop, wait
+from asyncio import Future, ensure_future, get_event_loop, iscoroutine, wait
+
 from graphql.pyutils.aplus import Promise
 
 
@@ -16,6 +17,7 @@ def handle_future_result(future):
 
 
 class AsyncioExecutor(object):
+
     def __init__(self):
         self.loop = get_event_loop()
         self.futures = []

graphql/execution/executors/gevent.py

@@ -1,11 +1,13 @@
 from __future__ import absolute_import
 
 import gevent
-from .utils import process
+
 from ...pyutils.aplus import Promise
+from .utils import process
 
 
 class GeventExecutor(object):
+
     def __init__(self):
         self.jobs = []
 

graphql/execution/executors/process.py

@@ -1,13 +1,16 @@
-from multiprocessing import Pool, Process, Queue
+from multiprocessing import Process, Queue
+
 from ...pyutils.aplus import Promise
 from .utils import process
 
+
 def queue_process(q):
     promise, fn, args, kwargs = q.get()
     process(promise, fn, args, kwargs)
 
 
 class ProcessExecutor(object):
+
     def __init__(self):
         self.processes = []
         self.q = Queue()
@@ -20,8 +23,8 @@ def wait_until_finished(self):
 
     def execute(self, fn, *args, **kwargs):
         promise = Promise()
-        
-        q.put([promise, fn, args, kwargs], False)
+
+        self.q.put([promise, fn, args, kwargs], False)
         _process = Process(target=queue_process, args=(self.q))
         _process.start()
         self.processes.append(_process)

graphql/execution/executors/sync.py

@@ -1,4 +1,5 @@
 class SyncExecutor(object):
+
     def wait_until_finished(self):
         pass
 

graphql/execution/executors/thread.py

@@ -1,9 +1,11 @@
 from threading import Thread
+
 from ...pyutils.aplus import Promise
 from .utils import process
 
 
 class ThreadExecutor(object):
+
     def __init__(self):
         self.threads = []
 

graphql/execution/tests/test_concurrent_executor.py

@@ -1,16 +1,16 @@
-from collections import OrderedDict
 
 from graphql.error import format_error
+from graphql.execution.execute import execute
+from graphql.language.parser import parse
 from graphql.type import (GraphQLArgument, GraphQLField, GraphQLInt,
                           GraphQLList, GraphQLObjectType, GraphQLSchema,
                           GraphQLString)
 from graphql.type.definition import GraphQLNonNull
-from graphql.execution.execute import execute
-from graphql.language.parser import parse
 
-# from .utils import raise_callback_results
-from .utils import resolved, rejected
 from ..executors.thread import ThreadExecutor
+# from .utils import raise_callback_results
+from .utils import rejected, resolved
+
 
 def test_executes_arbitary_code():
     class Data(object):
@@ -118,7 +118,15 @@ def handle_result(result):
         assert not result.errors
         assert result.data == expected
 
-    handle_result(execute(schema, ast, Data(), variable_values={'size': 100}, operation_name='Example', executor=ThreadExecutor()))
+    handle_result(
+        execute(
+            schema,
+            ast,
+            Data(),
+            variable_values={
+                'size': 100},
+            operation_name='Example',
+            executor=ThreadExecutor()))
     handle_result(execute(schema, ast, Data(), variable_values={'size': 100}, operation_name='Example'))
 
 

graphql/execution/tests/test_execute.py

@@ -1,5 +1,4 @@
 import json
-from collections import OrderedDict
 
 from pytest import raises