Improved types as containers

Author: syrusakbary

README.md

@@ -1,10 +1,10 @@
-# ![Graphene Logo](http://graphene-python.org/favicon.png) [Graphene](http://graphene-python.org) [![Build Status](https://travis-ci.org/graphql-python/graphene.svg?branch=master)](https://travis-ci.org/graphql-python/graphene) [![Coverage Status](https://coveralls.io/repos/graphql-python/graphene/badge.svg?branch=master&service=github)](https://coveralls.io/github/graphql-python/graphene?branch=master)
+# ![Graphene Logo](http://graphene-python.org/favicon.png) [Graphene](http://graphene-python.org) [![Build Status](https://travis-ci.org/graphql-python/graphene.svg?branch=master)](https://travis-ci.org/graphql-python/graphene) [![PyPI version](https://badge.fury.io/py/graphene.svg)](https://badge.fury.io/py/graphene) [![Coverage Status](https://coveralls.io/repos/graphql-python/graphene/badge.svg?branch=master&service=github)](https://coveralls.io/github/graphql-python/graphene?branch=master)
 
 
 Graphene is a Python library for building GraphQL schemas/types fast and easily.
 * **Easy to use:** It maps the models/fields to internal GraphQL objects without effort.
 * **Relay:** Graphene has builtin support for Relay
-* **Django:** Automatic [Django models](#djangorelay-schema) conversion. *See an [example Django](http://github.com/graphql-python/swapi-graphene) implementation*
+* **Django:** Automatic *Django model* mapping to Graphene Types. *See an [example Django](http://github.com/graphql-python/swapi-graphene) implementation*
 
 
 ## Installation
@@ -16,26 +16,21 @@ pip install graphene
 ```
 
 
-## Usage
+## Examples
 
-Example code of a GraphQL schema using Graphene:
-
-### Schema definition
+Here is one example for get you started:
 
 ```python
-class Character(graphene.Interface):
-    id = graphene.IDField()
-    name = graphene.StringField()
-    friends = graphene.ListField('self')
+class Query(graphene.ObjectType):
+    hello = graphene.StringField(description='A typical hello world')
+    ping = graphene.StringField(description='Ping someone',
+                                to=graphene.Argument(graphene.String))
 
-    def resolve_friends(self, args, *_):
-        return [Human(f) for f in self.instance.friends]
+    def resolve_hello(self, args, info):
+        return 'World'
 
-class Human(Character):
-    homePlanet = graphene.StringField()
-
-class Query(graphene.ObjectType):
-    human = graphene.Field(Human)
+    def resolve_ping(self, args, info):
+        return 'Pinging {}'.format(args.get('to'))
 
 schema = graphene.Schema(query=Query)
 ```
@@ -44,48 +39,19 @@ Then Querying `graphene.Schema` is as simple as:
 
 ```python
 query = '''
-    query HeroNameQuery {
-      hero {
-        name
-      }
+    query SayHello {
+      hello
+      ping(to:'peter')
     }
 '''
 result = schema.execute(query)
 ```
 
-### Relay Schema
-
-Graphene also supports Relay, check the [Starwars Relay example](tests/starwars_relay)!
-
-```python
-class Ship(relay.Node):
-    name = graphene.StringField()
-
-    @classmethod
-    def get_node(cls, id):
-        return Ship(your_ship_instance)
-
-
-class Query(graphene.ObjectType):
-    ships = relay.ConnectionField(Ship)
-    node = relay.NodeField()
-
-```
-
-### Django+Relay Schema
+If you want to learn even more, you can also check the following examples:
 
-If you want to use graphene with your Django Models check the [Starwars Django example](tests/starwars_django)!
+* Relay Schema: [Starwars Relay example](tests/starwars_relay)
+* Django: [Starwars Django example](tests/starwars_django)
 
-```python
-class Ship(DjangoNode):
-    class Meta:
-        model = YourDjangoModelHere
-        # only_fields = ('id', 'name') # Only map this fields from the model
-        # exclude_fields ('field_to_exclude', ) # Exclude mapping this fields from the model
-
-class Query(graphene.ObjectType):
-    node = relay.NodeField()
-```
 
 ## Contributing
 

graphene/contrib/django/types.py

@@ -37,11 +37,20 @@ def add_extra_fields(cls):
             cls.add_to_class(field.name, converted_field)
 
 
-class DjangoObjectType(six.with_metaclass(DjangoObjectTypeMeta, BaseObjectType)):
+class InstanceObjectType(BaseObjectType):
+    def __init__(self, instance=None):
+        self.instance = instance
+        super(InstanceObjectType, self).__init__()
+
+    def __getattr__(self, attr):
+        return getattr(self.instance, attr)
+
+
+class DjangoObjectType(six.with_metaclass(DjangoObjectTypeMeta, InstanceObjectType)):
     pass
 
 
-class DjangoInterface(six.with_metaclass(DjangoObjectTypeMeta, BaseObjectType)):
+class DjangoInterface(six.with_metaclass(DjangoObjectTypeMeta, InstanceObjectType)):
     pass
 
 

graphene/core/fields.py

@@ -28,7 +28,7 @@ class Field(object):
     creation_counter = 0
     required = False
 
-    def __init__(self, field_type, name=None, resolve=None, required=False, args=None, description='', **extra_args):
+    def __init__(self, field_type, name=None, resolve=None, required=False, args=None, description='', default=None, **extra_args):
         self.field_type = field_type
         self.resolve_fn = resolve
         self.required = self.required or required
@@ -38,9 +38,13 @@ def __init__(self, field_type, name=None, resolve=None, required=False, args=Non
         self.name = name
         self.description = description or self.__doc__
         self.object_type = None
+        self.default = default
         self.creation_counter = Field.creation_counter
         Field.creation_counter += 1
 
+    def get_default(self):
+        return self.default
+
     def contribute_to_class(self, cls, name, add=True):
         if not self.name:
             self.name = to_camel_case(name)
@@ -57,7 +61,7 @@ def resolve(self, instance, args, info):
         if resolve_fn:
             return resolve_fn(instance, args, info)
         else:
-            return getattr(instance, self.field_name, None)
+            return getattr(instance, self.field_name, self.get_default())
 
     def get_resolve_fn(self, schema):
         object_type = self.get_object_type(schema)

graphene/core/types.py

@@ -129,29 +129,48 @@ def add_to_class(cls, name, value):
 
 class BaseObjectType(object):
 
-    def __new__(cls, instance=None, **kwargs):
+    def __new__(cls, *args, **kwargs):
         if cls._meta.is_interface:
             raise Exception("An interface cannot be initialized")
-        if instance is None:
-            if not kwargs:
-                return None
-        elif type(instance) is cls:
-            return instance
-
+        if not args and not kwargs:
+            return None
         return super(BaseObjectType, cls).__new__(cls)
 
-    def __init__(self, instance=None, **kwargs):
-        signals.pre_init.send(self.__class__, instance=instance)
-        assert instance or kwargs
-        if not instance:
-            init_kwargs = dict({k: None for k in self._meta.fields_map.keys()}, **kwargs)
-            instance = self._meta.object(**init_kwargs)
-        self.instance = instance
-        signals.post_init.send(self.__class__, instance=self)
+    def __init__(self, *args, **kwargs):
+        signals.pre_init.send(self.__class__, args=args, kwargs=kwargs)
+        args_len = len(args)
+        fields = self._meta.fields
+        if args_len > len(fields):
+            # Daft, but matches old exception sans the err msg.
+            raise IndexError("Number of args exceeds number of fields")
+        fields_iter = iter(fields)
+
+        if not kwargs:
+            for val, field in zip(args, fields_iter):
+                setattr(self, field.field_name, val)
+        else:
+            for val, field in zip(args, fields_iter):
+                setattr(self, field.field_name, val)
+                kwargs.pop(field.field_name, None)
+
+        for field in fields_iter:
+            try:
+                val = kwargs.pop(field.field_name)
+                setattr(self, field.field_name, val)
+            except KeyError:
+                pass
+
+        if kwargs:
+            for prop in list(kwargs):
+                try:
+                    if isinstance(getattr(self.__class__, prop), property):
+                        setattr(self, prop, kwargs.pop(prop))
+                except AttributeError:
+                    pass
+            if kwargs:
+                raise TypeError("'%s' is an invalid keyword argument for this function" % list(kwargs)[0])
 
-    def __getattr__(self, name):
-        if self.instance:
-            return getattr(self.instance, name)
+        signals.post_init.send(self.__class__, instance=self)
 
     @classmethod
     def fields_as_arguments(cls, schema):

tests/relay/test_relay.py

@@ -32,21 +32,3 @@ def test_node_should_have_same_connection_always():
 
 def test_node_should_have_id_field():
     assert 'id' in OtherNode._meta.fields_map
-
-
-# def test_field_no_contributed_raises_error():
-#     with raises(Exception) as excinfo:
-#         class Ship(graphene.ObjectType):
-#             name = graphene.StringField()
-#             class Meta:
-#                 schema = schema
-
-#         class Faction(relay.Node):
-#             name = graphene.StringField()
-#             ships = relay.ConnectionField(Ship)
-#             @classmethod
-#             def get_node(cls):
-#                 pass
-#             class Meta:
-#                 schema = schema
-#     assert 'same type_name' in str(excinfo.value)

tests/relay/test_relayfields.py

@@ -1,4 +1,3 @@
-from pytest import raises
 from graphql.core.type import (
     GraphQLNonNull,
     GraphQLID
@@ -10,11 +9,6 @@
 schema = graphene.Schema()
 
 
-class MyType(object):
-    name = 'my'
-    arg = None
-
-
 class MyConnection(relay.Connection):
     my_custom_field = graphene.StringField(resolve=lambda instance, *_: 'Custom')
 
@@ -24,18 +18,17 @@ class MyNode(relay.Node):
 
     @classmethod
     def get_node(cls, id):
-        return MyNode(MyType())
+        return MyNode(name='mo')
 
 
 class Query(graphene.ObjectType):
     my_node = relay.NodeField(MyNode)
     all_my_nodes = relay.ConnectionField(MyNode, connection_type=MyConnection, customArg=graphene.Argument(graphene.String))
 
     def resolve_all_my_nodes(self, args, info):
-        t = MyType()
         custom_arg = args.get('customArg')
         assert custom_arg == "1"
-        return [MyNode(t)]
+        return [MyNode(name='my')]
 
 schema.query = Query
 
@@ -61,7 +54,7 @@ def test_nodefield_query():
     '''
     expected = {
         'myNode': {
-            'name': 'my'
+            'name': 'mo'
         },
         'allMyNodes': {
             'edges': [{