AST to object (namedtuple)

Author: dittos

graphql/core/__init__.py

@@ -1,5 +1,6 @@
 from .executor import execute
-from .language import Source, parse
+from .language.source import Source
+from .language.parser import parse
 
 
 def graphql(schema, request='', root=None, vars=None, operation_name=None):

graphql/core/executor/executor.py

@@ -3,7 +3,7 @@
 import re
 from ..error import GraphQLError, format_error
 from ..utils import type_from_ast, is_nullish
-from ..language import kinds as Kind
+from ..language import ast
 from .values import get_variable_values, get_argument_values
 from ..type.definition import (
     GraphQLScalarType,
@@ -53,21 +53,21 @@ class ExecutionContext(object):
 
     Namely, schema of the type system that is currently executing,
     and the fragments defined in the query document"""
-    def __init__(self, schema, root, ast, operation_name, args):
+    def __init__(self, schema, root, document_ast, operation_name, args):
         """Constructs a ExecutionContext object from the arguments passed
         to execute, which we will pass throughout the other execution
         methods."""
         errors = []
         operations = {}
         fragments = {}
-        for statement in ast['definitions']:
-            if statement['kind'] == Kind.OPERATION_DEFINITION:
+        for statement in document_ast.definitions:
+            if isinstance(statement, ast.OperationDefinition):
                 name = ''
-                if statement.get('name'):
-                    name = statement['name']['value']
+                if statement.name:
+                    name = statement.name.value
                 operations[name] = statement
-            elif statement['kind'] == Kind.FRAGMENT_DEFINITION:
-                fragments[statement['name']['value']] = statement
+            elif isinstance(statement, ast.FragmentDefinition):
+                fragments[statement.name.value] = statement
         if not operation_name and len(operations) != 1:
             raise GraphQLError(
                 'Must provide operation name '
@@ -76,7 +76,7 @@ def __init__(self, schema, root, ast, operation_name, args):
         operation = operations.get(op_name)
         if not operation:
             raise GraphQLError('Unknown operation name: {}'.format(op_name))
-        variables = get_variable_values(schema, operation['variableDefinitions'] or [], args)
+        variables = get_variable_values(schema, operation.variable_definitions or [], args)
 
         self.schema = schema
         self.fragments = fragments
@@ -113,14 +113,14 @@ def execute(schema, root, ast, operation_name='', args=None):
 def execute_operation(ctx, root, operation):
     """Implements the "Evaluating operations" section of the spec."""
     type = get_operation_root_type(ctx.schema, operation)
-    fields = collect_fields(ctx, type, operation['selectionSet'], {}, set())
-    if operation['operation'] == 'mutation':
+    fields = collect_fields(ctx, type, operation.selection_set, {}, set())
+    if operation.operation == 'mutation':
         return execute_fields_serially(ctx, type, root, fields)
     return execute_fields(ctx, type, root, fields)
 
 
 def get_operation_root_type(schema, operation):
-    op = operation['operation']
+    op = operation.operation
     if op == 'query':
         return schema.get_query_type()
     elif op == 'mutation':
@@ -156,37 +156,36 @@ def execute_fields(ctx, parent_type, source, fields):
 
 
 def collect_fields(ctx, type, selection_set, fields, prev_fragment_names):
-    for selection in selection_set['selections']:
-        kind = selection['kind']
-        directives = selection.get('directives')
-        if kind == Kind.FIELD:
+    for selection in selection_set.selections:
+        directives = selection.directives
+        if isinstance(selection, ast.Field):
             if not should_include_node(ctx, directives):
                 continue
             name = get_field_entry_key(selection)
             if name not in fields:
                 fields[name] = []
             fields[name].append(selection)
-        elif kind == Kind.INLINE_FRAGMENT:
+        elif isinstance(selection, ast.InlineFragment):
             if not should_include_node(ctx, directives) or \
                     not does_fragment_condition_match(ctx, selection, type):
                 continue
             collect_fields(
-                ctx, type, selection['selectionSet'],
+                ctx, type, selection.selection_set,
                 fields, prev_fragment_names)
-        elif kind == Kind.FRAGMENT_SPREAD:
-            frag_name = selection['name']['value']
+        elif isinstance(selection, ast.FragmentSpread):
+            frag_name = selection.name.value
             if frag_name in prev_fragment_names or \
                     not should_include_node(ctx, directives):
                 continue
             prev_fragment_names.add(frag_name)
             fragment = ctx.fragments.get(frag_name)
-            frag_directives = fragment.get('directives')
+            frag_directives = fragment.directives
             if not fragment or \
                     not should_include_node(ctx, frag_directives) or \
                     not does_fragment_condition_match(ctx, fragment, type):
                 continue
             collect_fields(
-                ctx, type, fragment['selectionSet'],
+                ctx, type, fragment.selection_set,
                 fields, prev_fragment_names)
     return fields
 
@@ -197,26 +196,26 @@ def should_include_node(ctx, directives):
     if directives:
         skip_ast = None
         for directive in directives:
-            if directive['name']['value'] == GraphQLSkipDirective.name:
+            if directive.name.value == GraphQLSkipDirective.name:
                 skip_ast = directive
                 break
         if skip_ast:
             args = get_argument_values(
                 GraphQLSkipDirective.args,
-                skip_ast['arguments'],
+                skip_ast.arguments,
                 ctx.variables,
             )
             return not args.get('if')
 
         include_ast = None
         for directive in directives:
-            if directive['name']['value'] == GraphQLIncludeDirective.name:
+            if directive.name.value == GraphQLIncludeDirective.name:
                 include_ast = directive
                 break
         if include_ast:
             args = get_argument_values(
                 GraphQLIncludeDirective.args,
-                include_ast['arguments'],
+                include_ast.arguments,
                 ctx.variables,
             )
             return bool(args.get('if'))
@@ -225,7 +224,7 @@ def should_include_node(ctx, directives):
 
 
 def does_fragment_condition_match(ctx, fragment, type_):
-    conditional_type = type_from_ast(ctx.schema, fragment['typeCondition'])
+    conditional_type = type_from_ast(ctx.schema, fragment.type_condition)
     if type(conditional_type) == type(type_):
         return True
     if isinstance(conditional_type, (GraphQLInterfaceType, GraphQLUnionType)):
@@ -235,9 +234,9 @@ def does_fragment_condition_match(ctx, fragment, type_):
 
 def get_field_entry_key(node):
     """Implements the logic to compute the key of a given field’s entry"""
-    if node['alias']:
-        return node['alias']['value']
-    return node['name']['value']
+    if node.alias:
+        return node.alias.value
+    return node.name.value
 
 
 def resolve_field(ctx, parent_type, source, field_asts):
@@ -256,7 +255,7 @@ def resolve_field(ctx, parent_type, source, field_asts):
     # TODO: find a way to memoize, in case this field is within a list type.
     if field_def.args is not None:
         args = get_argument_values(
-            field_def.args, field_ast['arguments'], ctx.variables
+            field_def.args, field_ast.arguments, ctx.variables
         )
     else:
         args = None
@@ -358,7 +357,7 @@ def complete_value(ctx, field_type, field_asts, result):
     subfield_asts = {}
     visited_fragment_names = set()
     for field_ast in field_asts:
-        selection_set = field_ast.get('selectionSet')
+        selection_set = field_ast.selection_set
         if selection_set:
             subfield_asts = collect_fields(
                 ctx, object_type, selection_set,
@@ -377,7 +376,7 @@ def camel_to_snake_case(name):
 def default_resolve_fn(source, args, root, field_ast, *_):
     """If a resolve function is not given, then a default resolve behavior is used which takes the property of the source object
     of the same name as the field and returns it as the result, or if it's a function, returns the result of calling that function."""
-    name = field_ast['name']['value']
+    name = field_ast.name.value
     property = getattr(source, name, None)
     if property is None:
         property = getattr(source, camel_to_snake_case(name), None)
@@ -394,7 +393,7 @@ def get_field_def(schema, parent_type, field_ast):
     are allowed, like on a Union. __schema could get automatically
     added to the query type, but that would require mutating type
     definitions, which would cause issues."""
-    name = field_ast['name']['value']
+    name = field_ast.name.value
     if name == SchemaMetaFieldDef.name and \
             schema.get_query_type() == parent_type:
         return SchemaMetaFieldDef

graphql/core/executor/values.py

@@ -1,6 +1,6 @@
 import collections
 from ..error import GraphQLError
-from ..language import Kind
+from ..language import ast
 from ..type import (GraphQLNonNull, GraphQLList, GraphQLInputObjectType,
                     GraphQLScalarType, GraphQLEnumType, is_input_type)
 from ..utils import type_from_ast, is_nullish
@@ -20,7 +20,7 @@ def get_variable_values(schema, definition_asts, inputs):
         inputs = {}
     values = {}
     for def_ast in definition_asts:
-        var_name = def_ast['variable']['name']['value']
+        var_name = def_ast.variable.name.value
         value = get_variable_value(schema, def_ast, inputs.get(var_name))
         values[var_name] = value
     return values
@@ -32,13 +32,13 @@ def get_argument_values(arg_defs, arg_asts, variables):
     arg_ast_map = {}
     if arg_asts:
         for arg in arg_asts:
-            arg_ast_map[arg['name']['value']] = arg
+            arg_ast_map[arg.name.value] = arg
     result = {}
     for arg_def in arg_defs:
         name = arg_def.name
         value_ast = arg_ast_map.get(name)
         if value_ast:
-            value_ast = value_ast['value']
+            value_ast = value_ast.value
         value = coerce_value_ast(
             arg_def.type,
             value_ast,
@@ -52,25 +52,25 @@ def get_argument_values(arg_defs, arg_asts, variables):
 
 def get_variable_value(schema, definition_ast, input):
     """Given a variable definition, and any value of input, return a value which adheres to the variable definition, or throw an error."""
-    type = type_from_ast(schema, definition_ast['type'])
+    type = type_from_ast(schema, definition_ast.type)
     if not type or not is_input_type(type):
         raise GraphQLError(
             'Variable ${} expected value of type {} which cannot be used as an input type.'.format(
-                definition_ast['variable']['name']['value'],
-                print_ast(definition_ast['type']),
+                definition_ast.variable.name.value,
+                print_ast(definition_ast.type),
             ),
             [definition_ast]
         )
     if is_valid_value(type, input):
         if is_nullish(input):
-            default_value = definition_ast.get('defaultValue')
+            default_value = definition_ast.default_value
             if default_value:
                 return coerce_value_ast(type, default_value, None)
         return coerce_value(type, input)
     raise GraphQLError(
         'Variable ${} expected value of type {} but got: {}'.format(
-            definition_ast['variable']['name']['value'],
-            print_ast(definition_ast['type']),
+            definition_ast.variable.name.value,
+            print_ast(definition_ast.type),
             repr(input)
         ),
         [definition_ast]
@@ -165,8 +165,8 @@ def coerce_value_ast(type, value_ast, variables):
     if not value_ast:
         return None
 
-    if value_ast['kind'] == Kind.VARIABLE:
-        variable_name = value_ast['name']['value']
+    if isinstance(value_ast, ast.Variable):
+        variable_name = value_ast.name.value
         if not variables or variable_name not in variables:
             return None
         # Note: we're not doing any checking that this variable is correct. We're assuming that this query
@@ -175,25 +175,25 @@ def coerce_value_ast(type, value_ast, variables):
 
     if isinstance(type, GraphQLList):
         item_type = type.of_type
-        if value_ast['kind'] == Kind.ARRAY:
+        if isinstance(value_ast, ast.ListValue):
             return [coerce_value_ast(item_type, item_ast, variables)
-                    for item_ast in value_ast['values']]
+                    for item_ast in value_ast.values]
         else:
             return [coerce_value_ast(item_type, value_ast, variables)]
 
     if isinstance(type, GraphQLInputObjectType):
         fields = type.get_fields()
-        if value_ast['kind'] != Kind.OBJECT:
+        if not isinstance(value_ast, ast.ObjectValue):
             return None
         field_asts = {}
-        for field in value_ast['fields']:
-            field_asts[field['name']['value']] = field
+        for field in value_ast.fields:
+            field_asts[field.name.value] = field
         obj = {}
         for field_name, field in fields.items():
             field_ast = field_asts.get(field_name)
             field_value_ast = None
             if field_ast:
-                field_value_ast = field_ast['value']
+                field_value_ast = field_ast.value
             field_value = coerce_value_ast(
                 field.type, field_value_ast, variables
             )

graphql/core/language/__init__.py

@@ -1,7 +0,0 @@
-# flake8: noqa
-from .location import get_location
-from . import kinds as Kind
-from .lexer import Lexer
-from .parser import parse
-from .source import Source
-from .error import LanguageError

graphql/core/language/ast.py

@@ -0,0 +1,36 @@
+from collections import namedtuple
+
+# Name
+Name = namedtuple('Name', 'loc value')
+
+# Document
+Document = namedtuple('Document', 'loc definitions')
+OperationDefinition = namedtuple('OperationDefinition', 'loc operation name variable_definitions directives selection_set')
+VariableDefinition = namedtuple('VariableDefinition', 'loc variable type default_value')
+Variable = namedtuple('Variable', 'loc name')
+SelectionSet = namedtuple('SelectionSet', 'loc selections')
+Field = namedtuple('Field', 'loc alias name arguments directives selection_set')
+Argument = namedtuple('Argument', 'loc name value')
+
+# Fragments
+FragmentSpread = namedtuple('FragmentSpread', 'loc name directives')
+InlineFragment = namedtuple('InlineFragment', 'loc type_condition directives selection_set')
+FragmentDefinition = namedtuple('FragmentDefinition', 'loc name type_condition directives selection_set')
+
+# Values
+IntValue = namedtuple('IntValue', 'loc value')
+FloatValue = namedtuple('FloatValue', 'loc value')
+StringValue = namedtuple('StringValue', 'loc value')
+BooleanValue = namedtuple('BooleanValue', 'loc value')
+EnumValue = namedtuple('EnumValue', 'loc value')
+ListValue = namedtuple('ListValue', 'loc values')
+ObjectValue = namedtuple('ObjectValue', 'loc fields')
+ObjectField = namedtuple('ObjectField', 'loc name value')
+
+# Directives
+Directive = namedtuple('Directive', 'loc name arguments')
+
+# Types
+NamedType = namedtuple('NamedType', 'loc name')
+ListType = namedtuple('ListType', 'loc type')
+NonNullType = namedtuple('NonNullType', 'loc type')