Merge remote-tracking branch 'graphql-python/0.4.0' into use-graphql-django-view

Author: jhgg

README.md

@@ -28,9 +28,9 @@ Here is one example for get you started:
 
 ```python
 class Query(graphene.ObjectType):
-    hello = graphene.StringField(description='A typical hello world')
-    ping = graphene.StringField(description='Ping someone',
-                                to=graphene.Argument(graphene.String))
+    hello = graphene.String(description='A typical hello world')
+    ping = graphene.String(description='Ping someone',
+                           to=graphene.String())
 
     def resolve_hello(self, args, info):
         return 'World'

README.rst

@@ -35,9 +35,9 @@ Here is one example for get you started:
 .. code:: python
 
     class Query(graphene.ObjectType):
-        hello = graphene.StringField(description='A typical hello world')
-        ping = graphene.StringField(description='Ping someone',
-                                    to=graphene.Argument(graphene.String))
+        hello = graphene.String(description='A typical hello world')
+        ping = graphene.String(description='Ping someone',
+                               to=graphene.String())
 
         def resolve_hello(self, args, info):
             return 'World'

bin/autolinter

@@ -1,4 +1,5 @@
 #!/bin/bash
 
-autoflake ./ -r  --remove-unused-variables --remove-all-unused-imports --in-place
+autoflake ./ -r --remove-unused-variables --remove-all-unused-imports --in-place
+autopep8 ./ -r --in-place --experimental --aggressive --max-line-length 120
 isort -rc .

examples/starwars/schema.py

@@ -12,33 +12,33 @@
 
 
 class Character(graphene.Interface):
-    id = graphene.IDField()
-    name = graphene.StringField()
-    friends = graphene.ListField('self')
-    appears_in = graphene.ListField(Episode)
+    id = graphene.ID()
+    name = graphene.String()
+    friends = graphene.List('Character')
+    appears_in = graphene.List(Episode)
 
     def resolve_friends(self, args, *_):
         # The character friends is a list of strings
         return [get_character(f) for f in self.friends]
 
 
 class Human(Character):
-    home_planet = graphene.StringField()
+    home_planet = graphene.String()
 
 
 class Droid(Character):
-    primary_function = graphene.StringField()
+    primary_function = graphene.String()
 
 
 class Query(graphene.ObjectType):
     hero = graphene.Field(Character,
                           episode=graphene.Argument(Episode)
                           )
     human = graphene.Field(Human,
-                           id=graphene.Argument(graphene.String)
+                           id=graphene.String()
                            )
     droid = graphene.Field(Droid,
-                           id=graphene.Argument(graphene.String)
+                           id=graphene.String()
                            )
 
     @resolve_only_args

examples/starwars_django/schema.py

@@ -12,6 +12,7 @@
 
 
 class Ship(DjangoNode):
+
     class Meta:
         model = ShipModel
 
@@ -21,11 +22,13 @@ def get_node(cls, id):
 
 
 class Character(DjangoObjectType):
+
     class Meta:
         model = CharacterModel
 
 
 class Faction(DjangoNode):
+
     class Meta:
         model = FactionModel
 
@@ -35,9 +38,10 @@ def get_node(cls, id):
 
 
 class IntroduceShip(relay.ClientIDMutation):
+
     class Input:
-        ship_name = graphene.StringField(required=True)
-        faction_id = graphene.StringField(required=True)
+        ship_name = graphene.String(required=True)
+        faction_id = graphene.String(required=True)
 
     ship = graphene.Field(Ship)
     faction = graphene.Field(Faction)
@@ -48,7 +52,7 @@ def mutate_and_get_payload(cls, input, info):
         faction_id = input.get('faction_id')
         ship = create_ship(ship_name, faction_id)
         faction = get_faction(faction_id)
-        return IntroduceShip(ship=ship, faction=faction)
+        return IntroduceShip(ship=Ship(ship), faction=Faction(faction))
 
 
 class Query(graphene.ObjectType):

examples/starwars_relay/schema.py

@@ -8,7 +8,7 @@
 
 class Ship(relay.Node):
     '''A ship in the Star Wars saga'''
-    name = graphene.StringField(description='The name of the ship.')
+    name = graphene.String(description='The name of the ship.')
 
     @classmethod
     def get_node(cls, id):
@@ -17,7 +17,7 @@ def get_node(cls, id):
 
 class Faction(relay.Node):
     '''A faction in the Star Wars saga'''
-    name = graphene.StringField(description='The name of the faction.')
+    name = graphene.String(description='The name of the faction.')
     ships = relay.ConnectionField(
         Ship, description='The ships used by the faction.')
 
@@ -34,8 +34,8 @@ def get_node(cls, id):
 class IntroduceShip(relay.ClientIDMutation):
 
     class Input:
-        ship_name = graphene.StringField(required=True)
-        faction_id = graphene.StringField(required=True)
+        ship_name = graphene.String(required=True)
+        faction_id = graphene.String(required=True)
 
     ship = graphene.Field(Ship)
     faction = graphene.Field(Faction)

graphene/__init__.py

@@ -1,9 +1,5 @@
 from graphql.core.type import (
-    GraphQLEnumType as Enum,
-    GraphQLArgument as Argument,
-    GraphQLString as String,
-    GraphQLInt as Int,
-    GraphQLID as ID
+    GraphQLEnumType as Enum
 )
 
 from graphene import signals
@@ -14,12 +10,24 @@
 
 from graphene.core.types import (
     ObjectType,
+    InputObjectType,
     Interface,
     Mutation,
+    BaseType,
+    LazyType,
+    Argument,
+    Field,
+    InputField,
+    String,
+    Int,
+    Boolean,
+    ID,
+    Float,
+    List,
+    NonNull
 )
 
 from graphene.core.fields import (
-    Field,
     StringField,
     IntField,
     BooleanField,
@@ -33,7 +41,31 @@
     resolve_only_args
 )
 
-__all__ = ['Enum', 'Argument', 'String', 'Int', 'ID', 'signals', 'Schema',
-           'ObjectType', 'Interface', 'Mutation', 'Field', 'StringField',
-           'IntField', 'BooleanField', 'IDField', 'ListField', 'NonNullField',
-           'FloatField', 'resolve_only_args']
+__all__ = [
+    'Enum',
+    'Argument',
+    'String',
+    'Int',
+    'Boolean',
+    'Float',
+    'ID',
+    'List',
+    'NonNull',
+    'signals',
+    'Schema',
+    'BaseType',
+    'LazyType',
+    'ObjectType',
+    'InputObjectType',
+    'Interface',
+    'Mutation',
+    'Field',
+    'InputField',
+    'StringField',
+    'IntField',
+    'BooleanField',
+    'IDField',
+    'ListField',
+    'NonNullField',
+    'FloatField',
+    'resolve_only_args']

graphene/contrib/django/converter.py

@@ -3,8 +3,7 @@
 
 from graphene.contrib.django.fields import (ConnectionOrListField,
                                             DjangoModelField)
-from graphene.core.fields import (BooleanField, FloatField, IDField, IntField,
-                                  StringField)
+from graphene.core.types.scalars import ID, Boolean, Float, Int, String
 
 try:
     UUIDField = models.UUIDField
@@ -17,7 +16,8 @@ class UUIDField(object):
 @singledispatch
 def convert_django_field(field):
     raise Exception(
-        "Don't know how to convert the Django field %s (%s)" % (field, field.__class__))
+        "Don't know how to convert the Django field %s (%s)" %
+        (field, field.__class__))
 
 
 @convert_django_field.register(models.DateField)
@@ -28,12 +28,12 @@ def convert_django_field(field):
 @convert_django_field.register(models.URLField)
 @convert_django_field.register(UUIDField)
 def convert_field_to_string(field):
-    return StringField(description=field.help_text)
+    return String(description=field.help_text)
 
 
 @convert_django_field.register(models.AutoField)
 def convert_field_to_id(field):
-    return IDField(description=field.help_text)
+    return ID(description=field.help_text)
 
 
 @convert_django_field.register(models.PositiveIntegerField)
@@ -42,23 +42,23 @@ def convert_field_to_id(field):
 @convert_django_field.register(models.BigIntegerField)
 @convert_django_field.register(models.IntegerField)
 def convert_field_to_int(field):
-    return IntField(description=field.help_text)
+    return Int(description=field.help_text)
 
 
 @convert_django_field.register(models.BooleanField)
 def convert_field_to_boolean(field):
-    return BooleanField(description=field.help_text, required=True)
+    return Boolean(description=field.help_text, required=True)
 
 
 @convert_django_field.register(models.NullBooleanField)
 def convert_field_to_nullboolean(field):
-    return BooleanField(description=field.help_text)
+    return Boolean(description=field.help_text)
 
 
 @convert_django_field.register(models.DecimalField)
 @convert_django_field.register(models.FloatField)
 def convert_field_to_float(field):
-    return FloatField(description=field.help_text)
+    return Float(description=field.help_text)
 
 
 @convert_django_field.register(models.ManyToManyField)

graphene/contrib/django/fields.py

@@ -1,67 +1,64 @@
 from graphene import relay
 from graphene.contrib.django.utils import get_type_for_model, lazy_map
-from graphene.core.fields import Field, LazyField, ListField
+from graphene.core.exceptions import SkipField
+from graphene.core.fields import Field
+from graphene.core.types.base import FieldType
+from graphene.core.types.definitions import List
 from graphene.relay.utils import is_node
 
 
 class DjangoConnectionField(relay.ConnectionField):
 
     def wrap_resolved(self, value, instance, args, info):
         schema = info.schema.graphene_schema
-        return lazy_map(value, self.get_object_type(schema))
+        return lazy_map(value, self.type.get_object_type(schema))
 
 
-class LazyListField(ListField):
+class LazyListField(Field):
 
-    def resolve(self, instance, args, info):
+    def get_type(self, schema):
+        return List(self.type)
+
+    def resolver(self, instance, args, info):
         schema = info.schema.graphene_schema
-        resolved = super(LazyListField, self).resolve(instance, args, info)
+        resolved = super(LazyListField, self).resolver(instance, args, info)
         return lazy_map(resolved, self.get_object_type(schema))
 
 
-class ConnectionOrListField(LazyField):
+class ConnectionOrListField(Field):
 
-    def get_field(self, schema):
-        model_field = self.field_type
+    def internal_type(self, schema):
+        model_field = self.type
         field_object_type = model_field.get_object_type(schema)
         if is_node(field_object_type):
             field = DjangoConnectionField(model_field)
         else:
             field = LazyListField(model_field)
         field.contribute_to_class(self.object_type, self.name)
-        return field
+        return field.internal_type(schema)
 
 
-class DjangoModelField(Field):
+class DjangoModelField(FieldType):
 
     def __init__(self, model, *args, **kwargs):
-        super(DjangoModelField, self).__init__(None, *args, **kwargs)
         self.model = model
-
-    def resolve(self, instance, args, info):
-        resolved = super(DjangoModelField, self).resolve(instance, args, info)
-        schema = info.schema.graphene_schema
-        _type = self.get_object_type(schema)
-        assert _type, ("Field %s cannot be retrieved as the "
-                       "ObjectType is not registered by the schema" % (
-                           self.attname
-                       ))
-        return _type(resolved)
+        super(DjangoModelField, self).__init__(*args, **kwargs)
 
     def internal_type(self, schema):
         _type = self.get_object_type(schema)
-        if not _type and self.object_type._meta.only_fields:
+        if not _type and self.parent._meta.only_fields:
             raise Exception(
                 "Model %r is not accessible by the schema. "
                 "You can either register the type manually "
                 "using @schema.register. "
-                "Or disable the field %s in %s" % (
+                "Or disable the field in %s" % (
                     self.model,
-                    self.attname,
-                    self.object_type
+                    self.parent,
                 )
             )
-        return schema.T(_type) or Field.SKIP
+        if not _type:
+            raise SkipField()
+        return schema.T(_type)
 
     def get_object_type(self, schema):
         return get_type_for_model(schema, self.model)

graphene/contrib/django/options.py

@@ -32,6 +32,7 @@ def contribute_to_class(self, cls, name):
             return
         if not self.model:
             raise Exception(
-                'Django ObjectType %s must have a model in the Meta class attr' % cls)
+                'Django ObjectType %s must have a model in the Meta class attr' %
+                cls)
         elif not inspect.isclass(self.model) or not issubclass(self.model, models.Model):
             raise Exception('Provided model in %s is not a Django model' % cls)