Merge branch 'master' into py36_support

Author: syrusakbary

.pre-commit-config.yaml

@@ -0,0 +1,18 @@
+-   repo: git://github.com/pre-commit/pre-commit-hooks
+    sha: v0.8.0
+    hooks:
+    -   id: autopep8-wrapper
+        args:
+        - -i
+        - --ignore=E128,E309,E501
+        exclude: ^docs/.*$
+    -   id: check-json
+    -   id: check-yaml
+    -   id: debug-statements
+    -   id: end-of-file-fixer
+        exclude: ^docs/.*$
+    -   id: trailing-whitespace
+    -   id: pretty-format-json
+        args:
+        - --autofix
+        - --indent=4

README.md

@@ -17,13 +17,13 @@ For questions, ask [Stack Overflow](http://stackoverflow.com/questions/tagged/gr
 
 ## Getting Started
 
-An overview of the GraphQL language is available in the 
+An overview of the GraphQL language is available in the
 [README](https://github.com/facebook/graphql/blob/master/README.md) for the
-[Specification for GraphQL](https://github.com/facebook/graphql). 
+[Specification for GraphQL](https://github.com/facebook/graphql).
 
 The overview describes a simple set of GraphQL examples that exist as [tests](https://github.com/graphql-python/graphql-core/tree/master/tests/)
 in this repository. A good way to get started is to walk through that README and the corresponding tests
-in parallel. 
+in parallel.
 
 ### Using graphql-core
 

graphql/__init__.py

@@ -193,6 +193,16 @@
     Undefined,
 )
 
+# Utilities for dynamic execution engines
+from .backend import (
+    GraphQLBackend,
+    GraphQLDocument,
+    GraphQLCoreBackend,
+    GraphQLDeciderBackend,
+    GraphQLCachedBackend,
+    get_default_backend,
+    set_default_backend,
+)
 
 VERSION = (2, 0, 1, 'final', 0)
 __version__ = get_version(VERSION)
@@ -282,4 +292,11 @@
     'value_from_ast',
     'get_version',
     'Undefined',
+    'GraphQLBackend',
+    'GraphQLDocument',
+    'GraphQLCoreBackend',
+    'GraphQLDeciderBackend',
+    'GraphQLCachedBackend',
+    'get_default_backend',
+    'set_default_backend',
 )

graphql/backend/__init__.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+"""
+This module provides a dynamic way of using different
+engines for a GraphQL schema query resolution.
+"""
+
+from .base import GraphQLBackend, GraphQLDocument
+from .core import GraphQLCoreBackend
+from .decider import GraphQLDeciderBackend
+from .cache import GraphQLCachedBackend
+
+_default_backend = None
+
+
+def get_default_backend():
+    global _default_backend
+    if _default_backend is None:
+        _default_backend = GraphQLCoreBackend()
+    return _default_backend
+
+
+def set_default_backend(backend):
+    global _default_backend
+    assert isinstance(
+        backend, GraphQLBackend
+    ), "backend must be an instance of GraphQLBackend."
+    _default_backend = backend
+
+
+__all__ = [
+    "GraphQLBackend",
+    "GraphQLDocument",
+    "GraphQLCoreBackend",
+    "GraphQLDeciderBackend",
+    "GraphQLCachedBackend",
+    "get_default_backend",
+    "set_default_backend",
+]

graphql/backend/base.py

@@ -0,0 +1,31 @@
+from ..language import ast
+from abc import ABCMeta, abstractmethod
+import six
+
+
+class GraphQLBackend(six.with_metaclass(ABCMeta)):
+    @abstractmethod
+    def document_from_string(self, schema, request_string):
+        raise NotImplementedError(
+            "document_from_string method not implemented in {}.".format(self.__class__)
+        )
+
+
+class GraphQLDocument(object):
+    def __init__(self, schema, document_string, document_ast, execute):
+        self.schema = schema
+        self.document_string = document_string
+        self.document_ast = document_ast
+        self.execute = execute
+
+    def get_operations(self):
+        document_ast = self.document_ast
+        operations = {}
+        for definition in document_ast.definitions:
+            if isinstance(definition, ast.OperationDefinition):
+                if definition.name:
+                    operation_name = definition.name.value
+                else:
+                    operation_name = None
+                operations[operation_name] = definition.operation
+        return operations

graphql/backend/cache.py

@@ -0,0 +1,61 @@
+from hashlib import sha1
+from six import string_types
+from ..type import GraphQLSchema
+
+from .base import GraphQLBackend
+
+_cached_schemas = {}
+
+_cached_queries = {}
+
+
+def get_unique_schema_id(schema):
+    """Get a unique id given a GraphQLSchema"""
+    assert isinstance(schema, GraphQLSchema), (
+        "Must receive a GraphQLSchema as schema. Received {}"
+    ).format(repr(schema))
+
+    if schema not in _cached_schemas:
+        _cached_schemas[schema] = sha1(str(schema).encode("utf-8")).hexdigest()
+    return _cached_schemas[schema]
+
+
+def get_unique_document_id(query_str):
+    """Get a unique id given a query_string"""
+    assert isinstance(query_str, string_types), (
+        "Must receive a string as query_str. Received {}"
+    ).format(repr(query_str))
+
+    if query_str not in _cached_queries:
+        _cached_queries[query_str] = sha1(str(query_str).encode("utf-8")).hexdigest()
+    return _cached_queries[query_str]
+
+
+class GraphQLCachedBackend(GraphQLBackend):
+    def __init__(self, backend, cache_map=None, use_consistent_hash=False):
+        assert isinstance(
+            backend, GraphQLBackend
+        ), "Provided backend must be an instance of GraphQLBackend"
+        if cache_map is None:
+            cache_map = {}
+        self.backend = backend
+        self.cache_map = cache_map
+        self.use_consistent_hash = use_consistent_hash
+
+    def get_key_for_schema_and_document_string(self, schema, request_string):
+        """This method returns a unique key given a schema and a request_string"""
+        if self.use_consistent_hash:
+            schema_id = get_unique_schema_id(schema)
+            document_id = get_unique_document_id(request_string)
+            return (schema_id, document_id)
+        return hash((schema, request_string))
+
+    def document_from_string(self, schema, request_string):
+        """This method returns a GraphQLQuery (from cache if present)"""
+        key = self.get_key_for_schema_and_document_string(schema, request_string)
+        if key not in self.cache_map:
+            self.cache_map[key] = self.backend.document_from_string(
+                schema, request_string
+            )
+
+        return self.cache_map[key]

graphql/backend/compiled.py

@@ -0,0 +1,37 @@
+from .base import GraphQLDocument
+
+
+class GraphQLCompiledDocument(GraphQLDocument):
+    @classmethod
+    def from_code(cls, schema, code, uptodate=None, extra_namespace=None):
+        """Creates a GraphQLDocument object from compiled code and the globals.  This
+        is used by the loaders and schema to create a document object.
+        """
+        namespace = {"__file__": code.co_filename}
+        exec(code, namespace)
+        if extra_namespace:
+            namespace.update(extra_namespace)
+        rv = cls._from_namespace(schema, namespace)
+        rv._uptodate = uptodate
+        return rv
+
+    @classmethod
+    def from_module_dict(cls, schema, module_dict):
+        """Creates a template object from a module.  This is used by the
+        module loader to create a document object.
+        """
+        return cls._from_namespace(schema, module_dict)
+
+    @classmethod
+    def _from_namespace(cls, schema, namespace):
+        document_string = namespace.get("document_string", "")
+        document_ast = namespace.get("document_ast")
+        execute = namespace["execute"]
+
+        namespace["schema"] = schema
+        return cls(
+            schema=schema,
+            document_string=document_string,
+            document_ast=document_ast,
+            execute=execute,
+        )

graphql/backend/core.py

@@ -0,0 +1,42 @@
+from functools import partial
+from six import string_types
+
+from ..execution import execute, ExecutionResult
+from ..language.base import parse, print_ast
+from ..language import ast
+from ..validation import validate
+
+from .base import GraphQLBackend, GraphQLDocument
+
+
+def execute_and_validate(schema, document_ast, *args, **kwargs):
+    do_validation = kwargs.get('validate', True)
+    if do_validation:
+        validation_errors = validate(schema, document_ast)
+        if validation_errors:
+            return ExecutionResult(
+                errors=validation_errors,
+                invalid=True,
+            )
+
+    return execute(schema, document_ast, *args, **kwargs)
+
+
+class GraphQLCoreBackend(GraphQLBackend):
+    def __init__(self, executor=None, **kwargs):
+        super(GraphQLCoreBackend, self).__init__(**kwargs)
+        self.execute_params = {"executor": executor}
+
+    def document_from_string(self, schema, document_string):
+        if isinstance(document_string, ast.Document):
+            document_ast = document_string
+            document_string = print_ast(document_ast)
+        else:
+            assert isinstance(document_string, string_types), "The query must be a string"
+            document_ast = parse(document_string)
+        return GraphQLDocument(
+            schema=schema,
+            document_string=document_string,
+            document_ast=document_ast,
+            execute=partial(execute_and_validate, schema, document_ast, **self.execute_params),
+        )

graphql/backend/decider.py

@@ -0,0 +1,24 @@
+from .base import GraphQLBackend
+
+
+class GraphQLDeciderBackend(GraphQLBackend):
+    def __init__(self, backends=None):
+        if not backends:
+            raise Exception("Need to provide backends to decide into.")
+        if not isinstance(backends, (list, tuple)):
+            raise Exception("Provided backends need to be a list or tuple.")
+        self.backends = backends
+        super(GraphQLDeciderBackend, self).__init__()
+
+    def document_from_string(self, schema, request_string):
+        for backend in self.backends:
+            try:
+                return backend.document_from_string(schema, request_string)
+            except Exception:
+                continue
+
+        raise Exception(
+            "GraphQLDeciderBackend was not able to retrieve a document. Backends tried: {}".format(
+                repr(self.backends)
+            )
+        )