Make imports global

Author: syrusakbary

graphql/__init__.py

@@ -1,5 +1,5 @@
 '''
-GraphQL provides a Python implementation for the GraphQL specification
+GraphQL.js provides a reference implementation for the GraphQL specification
 but is also a useful utility for operating on GraphQL files and building
 sophisticated tools.
 
@@ -14,33 +14,143 @@
 
 This also includes utility functions for operating on GraphQL types and
 GraphQL documents to facilitate building tools.
+
+You may also import from each sub-directory directly. For example, the
+following two import statements are equivalent:
+
+    from graphql import parse
+    from graphql.language.base import parse
 '''
 
-from .execution import ExecutionResult, execute
-from .language.parser import parse
-from .language.source import Source
-from .validation import validate
-
-
-def graphql(schema, request='', root=None, args=None, operation_name=None):
-    try:
-        source = Source(request, 'GraphQL request')
-        ast = parse(source)
-        validation_errors = validate(schema, ast)
-        if validation_errors:
-            return ExecutionResult(
-                errors=validation_errors,
-                invalid=True,
-            )
-        return execute(
-            schema,
-            ast,
-            root,
-            operation_name=operation_name,
-            variable_values=args or {},
-        )
-    except Exception as e:
-        return ExecutionResult(
-            errors=[e],
-            invalid=True,
-        )
+
+# The primary entry point into fulfilling a GraphQL request.
+from .graphql import (
+  graphql
+)
+
+
+# Create and operate on GraphQL type definitions and schema.
+from .type import (  # no import order
+  GraphQLSchema,
+
+  # Definitions
+  GraphQLScalarType,
+  GraphQLObjectType,
+  GraphQLInterfaceType,
+  GraphQLUnionType,
+  GraphQLEnumType,
+  GraphQLInputObjectType,
+  GraphQLList,
+  GraphQLNonNull,
+
+  # Scalars
+  GraphQLInt,
+  GraphQLFloat,
+  GraphQLString,
+  GraphQLBoolean,
+  GraphQLID,
+
+  # Predicates
+  is_type,
+  is_input_type,
+  is_output_type,
+  is_leaf_type,
+  is_composite_type,
+  is_abstract_type,
+
+  # Un-modifiers
+  get_nullable_type,
+  get_named_type,
+)
+
+
+# Parse and operate on GraphQL language source files.
+from .language.base import (  # no import order
+  Source,
+  get_location,
+
+  # Parse
+  parse,
+  parse_value,
+
+  # Print
+  print_ast,
+
+  # Visit
+  visit,
+  ParallelVisitor,
+  TypeInfoVisitor,
+  BREAK,
+)
+
+
+# Execute GraphQL queries.
+from .execution import (  # no import order
+  execute,
+)
+
+
+# Validate GraphQL queries.
+from .validation import (  # no import order
+  validate,
+  specified_rules,
+)
+
+# Create and format GraphQL errors.
+from .error import (  # no import order
+  GraphQLError,
+  format_error,
+)
+
+
+# Utilities for operating on GraphQL type schema and parsed sources.
+from .utils.base import (  # no import order
+  # The GraphQL query recommended for a full schema introspection.
+  introspection_query,
+
+  # Gets the target Operation from a Document
+  get_operation_ast,
+
+  # Build a GraphQLSchema from an introspection result.
+  build_client_schema,
+
+  # Build a GraphQLSchema from a parsed GraphQL Schema language AST.
+  build_ast_schema,
+
+  # Extends an existing GraphQLSchema from a parsed GraphQL Schema
+  # language AST.
+  extend_schema,
+
+  # Print a GraphQLSchema to GraphQL Schema language.
+  print_schema,
+
+  # Create a GraphQLType from a GraphQL language AST.
+  type_from_ast,
+
+  # Create a JavaScript value from a GraphQL language AST.
+  value_from_ast,
+
+  # Create a GraphQL language AST from a JavaScript value.
+  ast_from_value,
+
+  # A helper to use within recursive-descent visitors which need to be aware of
+  # the GraphQL type system.
+  TypeInfo,
+
+  # Determine if JavaScript values adhere to a GraphQL type.
+  is_valid_value,
+
+  # Determine if AST values adhere to a GraphQL type.
+  is_valid_literal_value,
+
+  # Concatenates multiple AST together.
+  concat_ast,
+
+  # Comparators for types
+  is_equal_type,
+  is_type_sub_type_of,
+  do_types_overlap,
+
+  # Asserts a string is a valid GraphQL name.
+  assert_valid_name,
+)

graphql/error.py

@@ -6,13 +6,13 @@ class Error(Exception):
 
 
 class GraphQLError(Error):
-    __slots__ = 'message', 'nodes', 'stack', '_source', '_positions'
+    __slots__ = 'message', 'nodes', 'original_error', '_source', '_positions'
 
-    def __init__(self, message, nodes=None, stack=None, source=None, positions=None):
+    def __init__(self, message, nodes=None, original_error=None, source=None, positions=None):
         super(GraphQLError, self).__init__(message)
         self.message = message or 'An unknown error occurred.'
         self.nodes = nodes
-        self.stack = stack or message
+        self.original_error = original_error
         self._source = source
         self._positions = positions
 

graphql/graphql.py

@@ -0,0 +1,53 @@
+from .execution import ExecutionResult, execute
+from .language.parser import parse
+from .language.source import Source
+from .validation import validate
+
+
+# This is the primary entry point function for fulfilling GraphQL operations
+# by parsing, validating, and executing a GraphQL document along side a
+# GraphQL schema.
+
+# More sophisticated GraphQL servers, such as those which persist queries,
+# may wish to separate the validation and execution phases to a static time
+# tooling step, and a server runtime step.
+
+# schema:
+#    The GraphQL type system to use when validating and executing a query.
+# requestString:
+#    A GraphQL language formatted string representing the requested operation.
+# rootValue:
+#    The value provided as the first argument to resolver functions on the top
+#    level type (e.g. the query object type).
+# variableValues:
+#    A mapping of variable name to runtime value to use for all variables
+#    defined in the requestString.
+# operationName:
+#    The name of the operation to use if requestString contains multiple
+#    possible operations. Can be omitted if requestString contains only
+#    one operation.
+def graphql(schema, request_string='', root_value=None, context_value=None,
+            variable_values=None, operation_name=None, executor=None):
+    try:
+        source = Source(request_string, 'GraphQL request')
+        ast = parse(source)
+        validation_errors = validate(schema, ast)
+        if validation_errors:
+            return ExecutionResult(
+                errors=validation_errors,
+                invalid=True,
+            )
+        return execute(
+            schema,
+            ast,
+            root_value,
+            context_value,
+            operation_name=operation_name,
+            variable_values=variable_values or {},
+            executor=executor
+        )
+    except Exception as e:
+        return ExecutionResult(
+            errors=[e],
+            invalid=True,
+        )

graphql/language/base.py

@@ -0,0 +1,6 @@
+from .location import ( get_location )
+from .lexer import ( Lexer )
+from .parser import ( parse, parse_value )
+from .printer import ( print_ast )
+from .source import ( Source )
+from .visitor import ( visit, ParallelVisitor, TypeInfoVisitor, BREAK )

graphql/type/__init__.py

@@ -17,6 +17,8 @@
     is_composite_type,
     is_input_type,
     is_leaf_type,
+    is_type,
+    get_nullable_type,
     is_output_type
 )
 from .directives import (

graphql/utils/base.py

@@ -0,0 +1,49 @@
+# The GraphQL query recommended for a full schema introspection.
+from .introspection_query import ( introspection_query )
+
+# Gets the target Operation from a Document
+from .get_operation_ast import ( get_operation_ast )
+
+# Build a GraphQLSchema from an introspection result.
+from .build_client_schema import ( build_client_schema )
+
+# Build a GraphQLSchema from a parsed GraphQL Schema language AST.
+from .build_ast_schema import ( build_ast_schema )
+
+# Extends an existing GraphQLSchema from a parsed GraphQL Schema language AST.
+from .extend_schema import ( extend_schema )
+
+# Print a GraphQLSchema to GraphQL Schema language.
+from .schema_printer import ( print_schema, print_introspection_schema )
+
+# Create a GraphQLType from a GraphQL language AST.
+from .type_from_ast import ( type_from_ast )
+
+# Create a JavaScript value from a GraphQL language AST.
+from .value_from_ast import ( value_from_ast )
+
+# Create a GraphQL language AST from a JavaScript value.
+from .ast_from_value import ( ast_from_value )
+
+# A helper to use within recursive-descent visitors which need to be aware of
+# the GraphQL type system.
+from .type_info import ( TypeInfo )
+
+# Determine if JavaScript values adhere to a GraphQL type.
+from .is_valid_value import ( is_valid_value )
+
+# Determine if AST values adhere to a GraphQL type.
+from .is_valid_literal_value import ( is_valid_literal_value )
+
+# Concatenates multiple AST together.
+from .concat_ast import ( concat_ast )
+
+# Comparators for types
+from .type_comparators import (
+  is_equal_type,
+  is_type_sub_type_of,
+  do_types_overlap
+)
+
+# Asserts that a string is a valid GraphQL name
+from .assert_valid_name import ( assert_valid_name )

graphql/validation/__init__.py

@@ -1,20 +1,2 @@
-from ..language.visitor import ParallelVisitor, TypeInfoVisitor, visit
-from ..type import GraphQLSchema
-from ..utils.type_info import TypeInfo
-from .context import ValidationContext
+from .validation import validate
 from .rules import specified_rules
-
-
-def validate(schema, ast, rules=specified_rules):
-    assert schema, 'Must provide schema'
-    assert ast, 'Must provide document'
-    assert isinstance(schema, GraphQLSchema)
-    type_info = TypeInfo(schema)
-    return visit_using_rules(schema, type_info, ast, rules)
-
-
-def visit_using_rules(schema, type_info, ast, rules):
-    context = ValidationContext(schema, ast, type_info)
-    visitors = [rule(context) for rule in rules]
-    visit(ast, TypeInfoVisitor(type_info, ParallelVisitor(visitors)))
-    return context.get_errors()

graphql/validation/tests/test_validation.py

@@ -1,6 +1,6 @@
 from graphql import parse, validate
 from graphql.utils.type_info import TypeInfo
-from graphql.validation import visit_using_rules
+from graphql.validation.validate import visit_using_rules
 from graphql.validation.rules import specified_rules
 
 from .utils import test_schema

graphql/validation/context.py renamed to graphql/validation/validation.py

@@ -1,6 +1,24 @@
 from ..language.ast import (FragmentDefinition, FragmentSpread,
                             OperationDefinition)
-from ..language.visitor import TypeInfoVisitor, Visitor, visit
+from ..language.visitor import ParallelVisitor, TypeInfoVisitor, Visitor, visit
+from ..type import GraphQLSchema
+from ..utils.type_info import TypeInfo
+from .rules import specified_rules
+
+
+def validate(schema, ast, rules=specified_rules):
+    assert schema, 'Must provide schema'
+    assert ast, 'Must provide document'
+    assert isinstance(schema, GraphQLSchema)
+    type_info = TypeInfo(schema)
+    return visit_using_rules(schema, type_info, ast, rules)
+
+
+def visit_using_rules(schema, type_info, ast, rules):
+    context = ValidationContext(schema, ast, type_info)
+    visitors = [rule(context) for rule in rules]
+    visit(ast, TypeInfoVisitor(type_info, ParallelVisitor(visitors)))
+    return context.get_errors()
 
 
 class VariableUsage(object):