Use 88 char line length for docstrings and docs

Author: Cito

README.md

@@ -11,28 +11,28 @@ a query language for APIs created by Facebook.
 [![Dependency Updates](https://pyup.io/repos/github/graphql-python/graphql-core-next/shield.svg)](https://pyup.io/repos/github/graphql-python/graphql-core-next/)
 [![Python 3 Status](https://pyup.io/repos/github/graphql-python/graphql-core-next/python-3-shield.svg)](https://pyup.io/repos/github/graphql-python/graphql-core-next/)
 
-The current version 1.0.1 of GraphQL-core-next is up-to-date with GraphQL.js
-version 14.0.2. All parts of the API are covered by an extensive test suite of
-currently 1615 unit tests.
+The current version 1.0.1 of GraphQL-core-next is up-to-date with GraphQL.js version
+14.0.2. All parts of the API are covered by an extensive test suite of currently 1615
+unit tests.
 
 
 ## Documentation
 
 A more detailed documentation for GraphQL-core-next can be found at
 [graphql-core-next.readthedocs.io](https://graphql-core-next.readthedocs.io/).
 
-There will be also [blog articles](https://cito.github.io/tags/graphql/)
-with more usage examples.
+There will be also [blog articles](https://cito.github.io/tags/graphql/) with more usage
+examples.
 
 
 ## Getting started
 
 An overview of GraphQL in general is available in the
 [README](https://github.com/facebook/graphql/blob/master/README.md) for the
 [Specification for GraphQL](https://github.com/facebook/graphql). That overview
-describes a simple set of GraphQL examples that exist as [tests](tests)
-in this repository. A good way to get started with this repository is to walk
-through that README and the corresponding tests in parallel.
+describes a simple set of GraphQL examples that exist as [tests](tests) in this
+repository. A good way to get started with this repository is to walk through that
+README and the corresponding tests in parallel.
 
 
 ## Installation
@@ -41,16 +41,16 @@ GraphQL-core-next can be installed from PyPI using the built-in pip command:
 
     python -m pip install graphql-core-next
 
-Alternatively, you can also use [pipenv](https://docs.pipenv.org/) for
-installation in a virtual environment:
+Alternatively, you can also use [pipenv](https://docs.pipenv.org/) for installation in a
+virtual environment:
 
     pipenv install graphql-core-next
 
 
 ## Usage
 
-GraphQL-core-next provides two important capabilities: building a type schema,
-and serving queries against that type schema.
+GraphQL-core-next provides two important capabilities: building a type schema, and
+serving queries against that type schema.
 
 First, build a GraphQL type schema which maps to your code base:
 
@@ -68,20 +68,19 @@ schema = GraphQLSchema(
         }))
 ```
 
-This defines a simple schema with one type and one field, that resolves
-to a fixed value. The `resolve` function can return a value, a co-routine
-object or a list of these. It takes two positional arguments; the first one
-provides the root or the resolved parent field, the second one provides a
-`GraphQLResolveInfo` object which contains information about the execution
-state of the query, including a `context` attribute holding per-request state
-such as authentication information or database session. Any GraphQL arguments
-are passed to the `resolve` functions as individual keyword arguments.
-
-Note that the signature of the resolver functions is a bit different in
-GraphQL.js, where the context is passed separately and arguments are passed
-as a single object. Also note that GraphQL fields must be passed as a
-`GraphQLField` object explicitly. Similarly, GraphQL arguments must be
-passed as `GraphQLArgument` objects.
+This defines a simple schema with one type and one field, that resolves to a fixed
+value. The `resolve` function can return a value, a co-routine object or a list of
+these. It takes two positional arguments; the first one provides the root or the
+resolved parent field, the second one provides a `GraphQLResolveInfo` object which
+contains information about the execution state of the query, including a `context`
+attribute holding per-request state such as authentication information or database
+session. Any GraphQL arguments are passed to the `resolve` functions as individual
+keyword arguments.
+
+Note that the signature of the resolver functions is a bit different in GraphQL.js,
+where the context is passed separately and arguments are passed as a single object.
+Also note that GraphQL fields must be passed as a `GraphQLField` object explicitly.
+Similarly, GraphQL arguments must be passed as `GraphQLArgument` objects.
 
 A more complex example is included in the top level [tests](tests) directory.
 
@@ -101,8 +100,8 @@ This runs a query fetching the one field defined, and then prints the result:
 ExecutionResult(data={'hello': 'world'}, errors=None)
 ```
 
-The `graphql_sync` function will first ensure the query is syntactically
-and semantically valid before executing it, reporting errors otherwise.
+The `graphql_sync` function will first ensure the query is syntactically and
+semantically valid before executing it, reporting errors otherwise.
 
 ```python
 from graphql import graphql_sync
@@ -120,9 +119,9 @@ ExecutionResult(data=None, errors=[GraphQLError(
     locations=[SourceLocation(line=1, column=3)])])
 ```
 
-The `graphql_sync` function assumes that all resolvers return values
-synchronously. By using coroutines as resolvers, you can also create
-results in an asynchronous fashion with the `graphql` function.
+The `graphql_sync` function assumes that all resolvers return values synchronously. By
+using coroutines as resolvers, you can also create results in an asynchronous fashion
+with the `graphql` function.
 
 ```python
 import asyncio
@@ -161,29 +160,29 @@ finally:
 
 ## Goals and restrictions
 
-GraphQL-core-next tries to reproduce the code of the reference implementation
-GraphQL.js in Python as closely as possible and to stay up-to-date with
-the latest development of GraphQL.js.
+GraphQL-core-next tries to reproduce the code of the reference implementation GraphQL.js
+in Python as closely as possible and to stay up-to-date with the latest development of
+GraphQL.js.
 
 It has been created as an alternative and potential successor to
-[GraphQL-core](https://github.com/graphql-python/graphql-core),
-a prior work by Syrus Akbary, based on an older version of GraphQL.js and
-also targeting older Python versions. GraphQL-core also serves as as the
-foundation for [Graphene](http://graphene-python.org/), a more high-level
-framework for building GraphQL APIs in Python. Some parts of GraphQL-core-next
-have been inspired by GraphQL-core or directly taken over with only slight
-modifications, but most of the code has been re-implemented from scratch,
-replicating the latest code in GraphQL.js very closely and adding type hints
-for Python. Though GraphQL-core has also been updated and modernized to some
-extend, it might be replaced by GraphQL-core-next in the future.
+[GraphQL-core](https://github.com/graphql-python/graphql-core), a prior work
+by Syrus Akbary, based on an older version of GraphQL.js and also targeting
+older Python versions. GraphQL-core also serves as as the foundation for
+[Graphene](http://graphene-python.org/), a more high-level framework for building
+GraphQL APIs in Python. Some parts of GraphQL-core-next have been inspired by
+GraphQL-core or directly taken over with only slight modifications, but most of the code
+has been re-implemented from scratch, replicating the latest code in GraphQL.js very
+closely and adding type hints for Python. Though GraphQL-core has also been updated and
+modernized to some extend, it might be replaced by GraphQL-core-next in the future.
 
 Design goals for the GraphQL-core-next library are:
 
-* to be a simple, cruft-free, state-of-the-art implementation of GraphQL using
-  current library and language versions
-* to be very close to the GraphQL.js reference implementation, while still
-  using a Pythonic API and code style
+* to be a simple, cruft-free, state-of-the-art implementation of GraphQL using current
+  library and language versions
+* to be very close to the GraphQL.js reference implementation, while still using a
+  Pythonic API and code style
 * making use of Python type hints, similar to how GraphQL.js makes use of Flow
+* using of [black](https://github.com/ambv/black) for automatic code formatting 
 * replicate the complete Mocha-based test suite of GraphQL.js using
   [pytest](https://docs.pytest.org/)
 
@@ -192,8 +191,7 @@ Some restrictions (mostly in line with the design goals):
 * requires Python 3.6 or 3.7
 * does not support some already deprecated methods and options of GraphQL.js
 * supports asynchronous operations only via async.io
-* does not support additional executors and middleware like GraphQL-core
-  (we are considering adding middleware later though)
+  (does not support the additional executors in GraphQL-core)
 * the benchmarks have not yet been ported to Python
 
 

docs/modules/error.rst

@@ -10,6 +10,6 @@ Error
 .. autofunction:: print_error
 .. autofunction:: format_error
 
-The :mod:`graphql.error` module also contains the :const:`INVALID` singleton
-that is used to describe invalid or undefined values and corresponds to the
-``undefined`` value in GraphQL.js.
+The :mod:`graphql.error` module also contains the :const:`INVALID` singleton that is
+used to describe invalid or undefined values and corresponds to the ``undefined``
+value in GraphQL.js.

docs/modules/language.rst

@@ -99,6 +99,5 @@ Visitor
 .. autoclass:: ParallelVisitor
 .. autoclass:: TypeInfoVisitor
 
-The module also exports the constants :const:`BREAK`, :const:`SKIP`,
-:const:`REMOVE` and :const:`IDLE` that are used as special return values
-in the :class:`Visitor` methods.
+The module also exports the constants :const:`BREAK`, :const:`SKIP`, :const:`REMOVE` and
+:const:`IDLE` that are used as special return values in the :class:`Visitor` methods.

docs/modules/utilities.rst

@@ -59,8 +59,8 @@ Create a GraphQL language AST from a Python value:
 
 .. autofunction:: ast_from_value
 
-A helper to use within recursive-descent visitors which need to be aware of
-the GraphQL type system:
+A helper to use within recursive-descent visitors which need to be aware of the GraphQL
+type system:
 
 .. autoclass:: TypeInfo
 

docs/modules/validation.rst

@@ -10,9 +10,9 @@ Validation
 Rules
 -----
 
-This list includes all validation rules defined by the GraphQL spec.
-The order of the rules in this list has been adjusted to lead to the
-most clear output when encountering multiple validation errors:
+This list includes all validation rules defined by the GraphQL spec. The order of the
+rules in this list has been adjusted to lead to the most clear output when encountering
+multiple validation errors:
 
 .. autodata:: specified_rules
 

docs/usage/extension.rst

@@ -1,12 +1,12 @@
 Extending a Schema
 ------------------
 
-With GraphQL-core-next you can also extend a given schema using type
-extensions. For example, we might want to add a ``lastName`` property to our
-``Human`` data type to retrieve only the last name of the person.
+With GraphQL-core-next you can also extend a given schema using type extensions. For
+example, we might want to add a ``lastName`` property to our ``Human`` data type to
+retrieve only the last name of the person.
 
-This can be achieved with the :func:`graphql.utilities.extend_schema`
-function as follows::
+This can be achieved with the :func:`graphql.utilities.extend_schema` function as
+follows::
 
     from graphql import extend_schema, parse
 
@@ -16,10 +16,9 @@ function as follows::
         }
         """))
 
-Note that this function expects the extensions as an AST, which we can
-get using the :func:`graphql.language.parse` function. Also note that
-the `extend_schema` function does not alter the original schema, but
-returns a new schema object.
+Note that this function expects the extensions as an AST, which we can get using the
+:func:`graphql.language.parse` function. Also note that the `extend_schema` function
+does not alter the original schema, but returns a new schema object.
 
 We also need to attach a resolver function to the new field::
 
@@ -45,3 +44,4 @@ This query will give the following result::
     ExecutionResult(
         data={'human': {'lastName': 'Skywalker', 'homePlanet': 'Tatooine'}},
         errors=None)
+

docs/usage/index.rst

@@ -1,8 +1,8 @@
 Usage
 =====
 
-GraphQL-core-next provides two important capabilities: building a type schema,
-and serving queries against that type schema.
+GraphQL-core-next provides two important capabilities: building a type schema, and
+serving queries against that type schema.
 
 .. toctree::
    :maxdepth: 2

docs/usage/introspection.rst

@@ -1,27 +1,26 @@
 Using an Introspection Query
 ----------------------------
 
-A third way of building a schema is using an introspection query on an
-existing server. This is what GraphiQL uses to get information about the
-schema on the remote server. You can create an introspection query using
-GraphQL-core-next with::
+A third way of building a schema is using an introspection query on an existing server.
+This is what GraphiQL uses to get information about the schema on the remote server. You
+can create an introspection query using GraphQL-core-next with::
 
     from graphql import get_introspection_query
 
     query = get_introspection_query(descriptions=True)
 
-This will also yield the descriptions of the introspected schema fields.
-You can also create a query that omits the descriptions with::
+This will also yield the descriptions of the introspected schema fields. You can also
+create a query that omits the descriptions with::
 
     query = get_introspection_query(descriptions=False)
 
-In practice you would run this query against a remote server, but we can
-also run it against the schema we have just built above::
+In practice you would run this query against a remote server, but we can also run it
+against the schema we have just built above::
 
     introspection_query_result = graphql_sync(schema, query)
 
-The ``data`` attribute of the introspection query result now gives us a
-dictionary, which constitutes a third way of describing a GraphQL schema::
+The ``data`` attribute of the introspection query result now gives us a dictionary,
+which constitutes a third way of describing a GraphQL schema::
 
     {'__schema': {
         'queryType': {'name': 'Query'},
@@ -36,21 +35,20 @@ dictionary, which constitutes a third way of describing a GraphQL schema::
         ... }
     }
 
-This result contains all the information that is available in the SDL
-description of the schema, i.e. it does not contain the resolve functions
-and information on the server-side values of the enum types.
+This result contains all the information that is available in the SDL description of the
+schema, i.e. it does not contain the resolve functions and information on the
+server-side values of the enum types.
 
-You can convert the introspection result into ``GraphQLSchema`` with
-GraphQL-core-next by using the :func:`graphql.utilities.build_client_schema`
-function::
+You can convert the introspection result into ``GraphQLSchema`` with GraphQL-core-next
+by using the :func:`graphql.utilities.build_client_schema` function::
 
     from graphql import build_client_schema
 
     client_schema = build_client_schema(introspection_query_result.data)
 
 
-It is also possible to convert the result to SDL with GraphQL-core-next by
-using the :func:`graphql.utilities.print_schema` function::
+It is also possible to convert the result to SDL with GraphQL-core-next by using the
+:func:`graphql.utilities.print_schema` function::
 
     from graphql import print_schema
 
@@ -59,5 +57,5 @@ using the :func:`graphql.utilities.print_schema` function::
 
 This prints the SDL representation of the schema that we started with.
 
-As you see, it is easy to convert between the three forms of representing
-a GraphQL schema in GraphQL-core-next.
+As you see, it is easy to convert between the three forms of representing a GraphQL
+schema in GraphQL-core-next.