Merge branch 'master' into feature/date-improvements

# Conflicts:
#	graphene/types/datetime.py

Author: syrusakbary

.gitignore

@@ -42,6 +42,7 @@ htmlcov/
 .coverage
 .coverage.*
 .cache
+.pytest_cache
 nosetests.xml
 coverage.xml
 *,cover

UPGRADE-v2.0.md

@@ -21,7 +21,7 @@ developer has to write to use them.
 
 
 > The type metaclasses are now deleted as they are no longer necessary.  If your code was depending
-> on this strategy for creating custom attrs, see an [example on how to do it in 2.0](https://github.com/graphql-python/graphene/blob/2.0/graphene/tests/issues/test_425.py).
+> on this strategy for creating custom attrs, see an [example on how to do it in 2.0](https://github.com/graphql-python/graphene/blob/v2.0.0/graphene/tests/issues/test_425.py).
 
 ## Deprecations
 

docs/execution/middleware.rst

@@ -3,7 +3,7 @@ Middleware
 
 You can use ``middleware`` to affect the evaluation of fields in your schema.
 
-A middleware is any object that responds to ``resolve(*args, next_middleware)``.
+A middleware is any object or function that responds to ``resolve(next_middleware, *args)``.
 
 Inside that method, it should either:
 
@@ -18,10 +18,8 @@ Middlewares ``resolve`` is invoked with several arguments:
 
 - ``next`` represents the execution chain. Call ``next`` to continue evalution.
 - ``root`` is the root value object passed throughout the query.
-- ``args`` is the hash of arguments passed to the field.
-- ``context`` is the context object passed throughout the query.
 - ``info`` is the resolver info.
-
+- ``args`` is the dict of arguments passed to the field.
 
 Example
 -------
@@ -42,3 +40,32 @@ And then execute it with:
 .. code:: python
 
     result = schema.execute('THE QUERY', middleware=[AuthorizationMiddleware()])
+
+
+Functional example
+------------------
+
+Middleware can also be defined as a function. Here we define a middleware that
+logs the time it takes to resolve each field
+
+.. code:: python
+
+    from time import time as timer
+
+    def timing_middleware(next, root, info, **args):
+        start = timer()
+        return_value = next(root, info, **args)
+        duration = timer() - start
+        logger.debug("{parent_type}.{field_name}: {duration} ms".format(
+            parent_type=root._meta.name if root and hasattr(root, '_meta') else '',
+            field_name=info.field_name,
+            duration=round(duration * 1000, 2)
+        ))
+        return return_value
+
+
+And then execute it with:
+
+.. code:: python
+
+    result = schema.execute('THE QUERY', middleware=[timing_middleware])

docs/relay/index.rst

@@ -21,9 +21,9 @@ Useful links
 -  `Relay Cursor Connection Specification`_
 -  `Relay input Object Mutation`_
 
-.. _Relay: https://facebook.github.io/relay/docs/graphql-relay-specification.html
+.. _Relay: https://facebook.github.io/relay/docs/en/graphql-server-specification.html
 .. _Relay specification: https://facebook.github.io/relay/graphql/objectidentification.htm#sec-Node-root-field
-.. _Getting started with Relay: https://facebook.github.io/relay/docs/graphql-relay-specification.html
+.. _Getting started with Relay: https://facebook.github.io/relay/docs/en/quick-start-guide.html
 .. _Relay Global Identification Specification: https://facebook.github.io/relay/graphql/objectidentification.htm
 .. _Relay Cursor Connection Specification: https://facebook.github.io/relay/graphql/connections.htm
 .. _Relay input Object Mutation: https://facebook.github.io/relay/graphql/mutations.htm

docs/relay/nodes.rst

@@ -55,12 +55,12 @@ Example of a custom node:
             return '{}:{}'.format(type, id)
 
         @staticmethod
-        def get_node_from_global_id(info global_id, only_type=None):
+        def get_node_from_global_id(info, global_id, only_type=None):
             type, id = global_id.split(':')
-            if only_node:
+            if only_type:
                 # We assure that the node type that we want to retrieve
                 # is the same that was indicated in the field type
-                assert type == only_node._meta.name, 'Received not compatible node.'
+                assert type == only_type._meta.name, 'Received not compatible node.'
 
             if type == 'User':
                 return get_user(id)
@@ -75,10 +75,10 @@ Accessing node types
 --------------------
 
 If we want to retrieve node instances from a ``global_id`` (scalar that identifies an instance by it's type name and id),
-we can simply do ``Node.get_node_from_global_id(global_id, context, info)``.
+we can simply do ``Node.get_node_from_global_id(info, global_id)``.
 
 In the case we want to restrict the instance retrieval to a specific type, we can do:
-``Node.get_node_from_global_id(global_id, context, info, only_type=Ship)``. This will raise an error
+``Node.get_node_from_global_id(info, global_id, only_type=Ship)``. This will raise an error
 if the ``global_id`` doesn't correspond to a Ship type.
 
 

docs/requirements.txt

@@ -1,4 +1,4 @@
 # Required library
 Sphinx==1.5.3
 # Docs template
-https://github.com/graphql-python/graphene-python.org/archive/docs.zip
+http://graphene-python.org/sphinx_graphene_theme.zip

docs/types/enums.rst

@@ -54,6 +54,13 @@ the ``Enum.from_enum`` function.
 
     graphene.Enum.from_enum(AlreadyExistingPyEnum)
 
+``Enum.from_enum`` supports a ``description`` and ``deprecation_reason`` lambdas as input so
+you can add description etc. to your enum without changing the original:
+
+.. code:: python
+
+    graphene.Enum.from_enum(AlreadyExistingPyEnum, description=lambda value: return 'foo' if value == AlreadyExistingPyEnum.Foo else 'bar')
+
 
 Notes
 -----
@@ -65,7 +72,7 @@ member getters.
 In the Python ``Enum`` implementation you can access a member by initing the Enum.
 
 .. code:: python
-    
+
     from enum import Enum
     class Color(Enum):
         RED = 1
@@ -78,7 +85,7 @@ In the Python ``Enum`` implementation you can access a member by initing the Enu
 However, in Graphene ``Enum`` you need to call get to have the same effect:
 
 .. code:: python
-    
+
     from graphene import Enum
     class Color(Enum):
         RED = 1

docs/types/list-and-nonnull.rst

@@ -48,3 +48,24 @@ Lists work in a similar way: We can use a type modifier to mark a type as a
 ``List``, which indicates that this field will return a list of that type.
 It works the same for arguments, where the validation step will expect a list
 for that value.
+
+NonNull Lists
+-------------
+
+By default items in a list will be considered nullable. To define a list without
+any nullable items the type needs to be marked as ``NonNull``. For example:
+
+.. code:: python
+
+    import graphene
+
+    class Character(graphene.ObjectType):
+        appears_in = graphene.List(graphene.NonNull(graphene.String))
+
+The above results in the type definition:
+
+.. code::
+
+    type Character {
+        appearsIn: [String!]
+    }

docs/types/scalars.rst

@@ -1,19 +1,83 @@
 Scalars
 =======
 
+All Scalar types accept the following arguments. All are optional:
+
+``name``: *string*
+
+    Override the name of the Field.
+
+``description``: *string*
+
+    A description of the type to show in the GraphiQL browser.
+
+``required``: *boolean*
+
+    If ``True``, the server will enforce a value for this field. See `NonNull <./list-and-nonnull.html#nonnull>`_. Default is ``False``.
+
+``deprecation_reason``: *string*
+
+    Provide a deprecation reason for the Field.
+
+``default_value``: *any*
+
+    Provide a default value for the Field.
+
+
+
+Base scalars
+------------
+
 Graphene defines the following base Scalar Types:
 
-- ``graphene.String``
-- ``graphene.Int``
-- ``graphene.Float``
-- ``graphene.Boolean``
-- ``graphene.ID``
+``graphene.String``
+
+    Represents textual data, represented as UTF-8
+    character sequences. The String type is most often used by GraphQL to
+    represent free-form human-readable text.
+
+``graphene.Int``
+
+    Represents non-fractional signed whole numeric
+    values. Int can represent values between `-(2^53 - 1)` and `2^53 - 1` since
+    represented in JSON as double-precision floating point numbers specified
+    by `IEEE 754 <http://en.wikipedia.org/wiki/IEEE_floating_point>`_.
+
+``graphene.Float``
+
+    Represents signed double-precision fractional
+    values as specified by
+    `IEEE 754 <http://en.wikipedia.org/wiki/IEEE_floating_point>`_.
+
+``graphene.Boolean``
+
+    Represents `true` or `false`.
+
+``graphene.ID``
+
+    Represents a unique identifier, often used to
+    refetch an object or as key for a cache. The ID type appears in a JSON
+    response as a String; however, it is not intended to be human-readable.
+    When expected as an input type, any string (such as `"4"`) or integer
+    (such as `4`) input value will be accepted as an ID.
 
 Graphene also provides custom scalars for Dates, Times, and JSON:
 
-- ``graphene.types.datetime.DateTime``
-- ``graphene.types.datetime.Time``
-- ``graphene.types.json.JSONString``
+``graphene.types.datetime.Date``
+
+    Represents a Date value as specified by `iso8601 <https://en.wikipedia.org/wiki/ISO_8601>`_.
+
+``graphene.types.datetime.DateTime``
+
+    Represents a DateTime value as specified by `iso8601 <https://en.wikipedia.org/wiki/ISO_8601>`_.
+
+``graphene.types.datetime.Time``
+
+    Represents a Time value as specified by `iso8601 <https://en.wikipedia.org/wiki/ISO_8601>`_.
+
+``graphene.types.json.JSONString``
+
+    Represents a JSON string.
 
 
 Custom scalars

docs/types/unions.rst

@@ -12,8 +12,8 @@ The basics:
 Quick example
 -------------
 
-This example model defines a ``Character`` interface with a name. ``Human``
-and ``Droid`` are two implementations of that interface.
+This example model defines several ObjectTypes with their own fields.
+``SearchResult`` is the implementation of ``Union`` of this object types.
 
 .. code:: python
 

graphene/__init__.py

@@ -34,7 +34,7 @@
 from .utils.module_loading import lazy_import
 
 
-VERSION = (2, 0, 0, 'final', 0)
+VERSION = (2, 0, 1, 'final', 0)
 
 __version__ = get_version(VERSION)
 

graphene/relay/connection.py

@@ -73,7 +73,7 @@ class EdgeBase(object):
         edge = type(edge_name, edge_bases, {})
         cls.Edge = edge
 
-        _meta.name = name
+        options['name'] = name
         _meta.node = node
         _meta.fields = OrderedDict([
             ('page_info', Field(PageInfo, name='pageInfo', required=True)),
@@ -99,16 +99,19 @@ def __init__(self, type, *args, **kwargs):
     def type(self):
         type = super(IterableConnectionField, self).type
         connection_type = type
-        if is_node(type):
+        if isinstance(type, NonNull):
+            connection_type = type.of_type
+
+        if is_node(connection_type):
             raise Exception(
                 "ConnectionField's now need a explicit ConnectionType for Nodes.\n"
-                "Read more: https://github.com/graphql-python/graphene/blob/2.0/UPGRADE-v2.0.md#node-connections"
+                "Read more: https://github.com/graphql-python/graphene/blob/v2.0.0/UPGRADE-v2.0.md#node-connections"
             )
 
         assert issubclass(connection_type, Connection), (
             '{} type have to be a subclass of Connection. Received "{}".'
         ).format(self.__class__.__name__, connection_type)
-        return connection_type
+        return type
 
     @classmethod
     def resolve_connection(cls, connection_type, args, resolved):
@@ -133,6 +136,9 @@ def resolve_connection(cls, connection_type, args, resolved):
     def connection_resolver(cls, resolver, connection_type, root, info, **args):
         resolved = resolver(root, info, **args)
 
+        if isinstance(connection_type, NonNull):
+            connection_type = connection_type.of_type
+
         on_resolve = partial(cls.resolve_connection, connection_type, args)
         if is_thenable(resolved):
             return Promise.resolve(resolved).then(on_resolve)

graphene/relay/tests/test_connection.py

@@ -1,6 +1,6 @@
 import pytest
 
-from ...types import Argument, Field, Int, List, NonNull, ObjectType, String
+from ...types import Argument, Field, Int, List, NonNull, ObjectType, String, Schema
 from ..connection import Connection, ConnectionField, PageInfo
 from ..node import Node
 
@@ -52,6 +52,21 @@ class Meta:
     assert list(fields.keys()) == ['page_info', 'edges', 'extra']
 
 
+def test_connection_name():
+    custom_name = "MyObjectCustomNameConnection"
+
+    class BaseConnection(object):
+        extra = String()
+
+    class MyObjectConnection(BaseConnection, Connection):
+
+        class Meta:
+            node = MyObject
+            name = custom_name
+
+    assert MyObjectConnection._meta.name == custom_name
+
+
 def test_edge():
     class MyObjectConnection(Connection):
 
@@ -122,9 +137,10 @@ def test_connectionfield_node_deprecated():
     field = ConnectionField(MyObject)
     with pytest.raises(Exception) as exc_info:
         field.type
-    
+
     assert "ConnectionField's now need a explicit ConnectionType for Nodes." in str(exc_info.value)
 
+
 def test_connectionfield_custom_args():
     class MyObjectConnection(Connection):
 
@@ -139,3 +155,23 @@ class Meta:
         'last': Argument(Int),
         'extra': Argument(String),
     }
+
+
+def test_connectionfield_required():
+    class MyObjectConnection(Connection):
+
+        class Meta:
+            node = MyObject
+
+    class Query(ObjectType):
+        test_connection = ConnectionField(MyObjectConnection, required=True)
+
+        def resolve_test_connection(root, info, **args):
+            return []
+
+    schema = Schema(query=Query)
+    executed = schema.execute(
+        '{ testConnection { edges { cursor } } }'
+    )
+    assert not executed.errors
+    assert executed.data == {'testConnection': {'edges': []}}