Added definitions

Author: syrusakbary

graphql/type/__init__.py

@@ -3,13 +3,15 @@
     GraphQLScalarType,
     GraphQLObjectType,
     GraphQLField,
+    GraphQLFieldDefinition,
     GraphQLArgument,
     GraphQLInterfaceType,
     GraphQLUnionType,
     GraphQLEnumType,
     GraphQLEnumValue,
     GraphQLInputObjectType,
     GraphQLInputObjectField,
+    GraphQLInputFieldDefinition,
     GraphQLList,
     GraphQLNonNull,
     get_named_type,

graphql/type/definition.py

@@ -220,18 +220,22 @@ def define_field_map(type, field_map):
             '{}.{} must be an instance of GraphQLField.'.format(type, field_name)
         )
 
-        field = copy.copy(field)
-        field.name = field_name
+        field_args = field.args
+
+        field = GraphQLFieldDefinition(
+            type=field.type,
+            name=field_name,
+            args=[],
+            resolver=field.resolver,
+            deprecation_reason=field.deprecation_reason,
+            description=field.description,
+        )
 
         assert is_output_type(field.type), (
             '{}.{} field type must be Output Type but got: {}.'.format(type, field_name, field.type)
         )
 
-        if not field.args:
-            field.args = []
-
-        else:
-            field_args = field.args
+        if field_args:
             assert isinstance(field_args, collections.Mapping), (
                 '{}.{} args must be a mapping (dict / OrderedDict) with argument names as keys.'.format(type,
                                                                                                         field_name)
@@ -242,16 +246,20 @@ def define_field_map(type, field_map):
 
             for arg_name, arg in field_args.items():
                 assert_valid_name(arg_name)
-                assert isinstance(arg, GraphQLArgument), (
+                assert isinstance(arg, (GraphQLArgument, GraphQLArgumentDefinition)), (
                     '{}.{}({}:) argument must be an instance of GraphQLArgument.'.format(type, field_name, arg_name)
                 )
                 assert is_input_type(arg.type), (
                     '{}.{}({}:) argument type must be Input Type but got: {}.'.format(type, field_name, arg_name,
                                                                                       arg.type)
                 )
 
-                arg = copy.copy(arg)
-                arg.name = arg_name
+                arg = GraphQLArgumentDefinition(
+                    type=arg.type,
+                    name=arg_name,
+                    default_value=arg.default_value,
+                    description=arg.description,
+                )
                 args.append(arg)
 
             field.args = args
@@ -289,10 +297,9 @@ def define_interfaces(type, interfaces):
 
 
 class GraphQLField(object):
-    __slots__ = 'name', 'type', 'args', 'resolver', 'deprecation_reason', 'description'
+    __slots__ = 'type', 'args', 'resolver', 'deprecation_reason', 'description'
 
     def __init__(self, type, args=None, resolver=None, deprecation_reason=None, description=None):
-        self.name = None
         self.type = type
         self.args = args
         self.resolver = resolver
@@ -303,7 +310,6 @@ def __eq__(self, other):
         return (
             self is other or (
                 isinstance(other, GraphQLField) and
-                self.name == other.name and
                 self.type == other.type and
                 self.args == other.args and
                 self.resolver == other.resolver and
@@ -316,11 +322,38 @@ def __hash__(self):
         return id(self)
 
 
+class GraphQLFieldDefinition(object):
+    __slots__ = 'name', 'type', 'args', 'resolver', 'deprecation_reason', 'description'
+
+    def __init__(self, type, name, args=None, resolver=None, deprecation_reason=None, description=None):
+        self.type = type
+        self.name = name
+        self.args = args
+        self.resolver = resolver
+        self.deprecation_reason = deprecation_reason
+        self.description = description
+
+    def __eq__(self, other):
+        return (
+            self is other or (
+                isinstance(other, GraphQLFieldDefinition) and
+                self.type == other.type and
+                self.name == other.name and
+                self.args == other.args and
+                self.resolver == other.resolver and
+                self.deprecation_reason == other.deprecation_reason and
+                self.description == other.description
+            )
+        )
+
+    def __hash__(self):
+        return id(self)
+
+
 class GraphQLArgument(object):
-    __slots__ = 'name', 'type', 'default_value', 'description'
+    __slots__ = 'type', 'default_value', 'description'
 
     def __init__(self, type, default_value=None, description=None):
-        self.name = None
         self.type = type
         self.default_value = default_value
         self.description = description
@@ -329,6 +362,29 @@ def __eq__(self, other):
         return (
             self is other or (
                 isinstance(other, GraphQLArgument) and
+                self.type == other.type and
+                self.default_value == other.default_value and
+                self.description == other.description
+            )
+        )
+
+    def __hash__(self):
+        return id(self)
+
+
+class GraphQLArgumentDefinition(object):
+    __slots__ = 'name', 'type', 'default_value', 'description'
+
+    def __init__(self, type, name, default_value=None, description=None):
+        self.type = type
+        self.name = name
+        self.default_value = default_value
+        self.description = description
+
+    def __eq__(self, other):
+        return (
+            self is other or (
+                isinstance(other, GraphQLArgumentDefinition) and
                 self.name == other.name and
                 self.type == other.type and
                 self.default_value == other.default_value and
@@ -610,24 +666,26 @@ def _define_field_map(self):
             assert isinstance(field, GraphQLInputObjectField), (
                 '{}.{} must be an instance of GraphQLInputObjectField.'.format(self, field_name)
             )
-
-            field = copy.copy(field)
-            field.name = field_name
-
             assert is_input_type(field.type), (
                 '{}.{} field type must be Input Type but got: {}.'.format(self, field_name, field.type)
             )
 
+            field = GraphQLInputFieldDefinition(
+                type=field.type,
+                name=field_name,
+                default_value=field.default_value,
+                description=field.description,
+            )
+
             field_map[field_name] = field
 
         return field_map
 
 
 class GraphQLInputObjectField(object):
-    __slots__ = 'name', 'type', 'default_value', 'description'
+    __slots__ = 'type', 'default_value', 'description'
 
     def __init__(self, type, default_value=None, description=None):
-        self.name = None
         self.type = type
         self.default_value = default_value
         self.description = description
@@ -636,6 +694,25 @@ def __eq__(self, other):
         return (
             self is other or (
                 isinstance(other, GraphQLInputObjectField) and
+                self.type == other.type and
+                self.description == other.description
+            )
+        )
+
+
+class GraphQLInputFieldDefinition(object):
+    __slots__ = 'name', 'type', 'default_value', 'description'
+
+    def __init__(self, type, name, default_value=None, description=None):
+        self.name = name
+        self.type = type
+        self.default_value = default_value
+        self.description = description
+
+    def __eq__(self, other):
+        return (
+            self is other or (
+                isinstance(other, GraphQLInputFieldDefinition) and
                 self.name == other.name and
                 self.type == other.type and
                 self.description == other.description

graphql/type/directives.py

@@ -1,7 +1,7 @@
 import collections
 
 from ..utils.assert_valid_name import assert_valid_name
-from .definition import GraphQLArgument, GraphQLNonNull, is_input_type
+from .definition import GraphQLArgument, GraphQLArgumentDefinition, GraphQLNonNull, is_input_type
 from .scalars import GraphQLBoolean
 
 
@@ -52,20 +52,14 @@ def __init__(self, name, description=None, args=None, locations=None):
                     name,
                     arg_name,
                     _arg.type)
-                self.args.append(arg(
-                    arg_name,
-                    description=_arg.description,
+                self.args.append(GraphQLArgumentDefinition(
                     type=_arg.type,
-                    default_value=_arg.default_value
+                    name=arg_name,
+                    description=_arg.description,
+                    default_value=_arg.default_value,
                 ))
 
 
-def arg(name, *args, **kwargs):
-    a = GraphQLArgument(*args, **kwargs)
-    a.name = name
-    return a
-
-
 GraphQLIncludeDirective = GraphQLDirective(
     name='include',
     args={

graphql/type/introspection.py

@@ -2,11 +2,11 @@
 
 from ..language.printer import print_ast
 from ..utils.ast_from_value import ast_from_value
-from .definition import (GraphQLArgument, GraphQLEnumType, GraphQLEnumValue,
+from .definition import (GraphQLArgument, GraphQLArgumentDefinition, GraphQLEnumType, GraphQLEnumValue,
                          GraphQLField, GraphQLInputObjectType,
                          GraphQLInterfaceType, GraphQLList, GraphQLNonNull,
                          GraphQLObjectType, GraphQLScalarType,
-                         GraphQLUnionType)
+                         GraphQLUnionType, GraphQLFieldDefinition)
 from .directives import DirectiveLocation
 from .scalars import GraphQLBoolean, GraphQLString
 
@@ -347,29 +347,28 @@ def input_fields(type, *_):
 
 IntrospectionSchema = __Schema
 
-SchemaMetaFieldDef = GraphQLField(
+SchemaMetaFieldDef = GraphQLFieldDefinition(
+    name='__schema',
     type=GraphQLNonNull(__Schema),
     description='Access the current type schema of this server.',
     resolver=lambda source, args, context, info: info.schema,
     args=[]
 )
-SchemaMetaFieldDef.name = '__schema'
 
-TypeMetaFieldDef_args_name = GraphQLArgument(GraphQLNonNull(GraphQLString))
-TypeMetaFieldDef_args_name.name = 'name'
-TypeMetaFieldDef = GraphQLField(
+TypeMetaFieldDef_args_name = GraphQLArgumentDefinition(GraphQLNonNull(GraphQLString), name='name')
+TypeMetaFieldDef = GraphQLFieldDefinition(
     type=__Type,
+    name='__type',
     description='Request the type information of a single type.',
     args=[TypeMetaFieldDef_args_name],
     resolver=lambda source, args, context, info: info.schema.get_type(args['name'])
 )
-TypeMetaFieldDef.name = '__type'
 del TypeMetaFieldDef_args_name
 
-TypeNameMetaFieldDef = GraphQLField(
+TypeNameMetaFieldDef = GraphQLFieldDefinition(
     type=GraphQLNonNull(GraphQLString),
+    name='__typename',
     description='The name of the current Object type at runtime.',
     resolver=lambda source, args, context, info: info.parent_type.name,
     args=[]
 )
-TypeNameMetaFieldDef.name = '__typename'

graphql/utils/build_client_schema.py

@@ -15,10 +15,12 @@
 from .value_from_ast import value_from_ast
 
 
-def _false(*_): return False
+def _false(*_):
+    return False
 
 
-def _none(*_): return None
+def _none(*_):
+    return None
 
 
 def no_execution(*args):
@@ -204,7 +206,6 @@ def build_input_value(input_value_introspection, argument_type):
             type=get_input_type(input_value_introspection['type']),
             default_value=build_default_value(input_value_introspection)
         )
-        input_value.name = input_value_introspection['name']
         return input_value
 
     def build_directive(directive_introspection):