Graphql-core

We're happy to announce `graphql-core` v0.4.9 is a stable release and is ready for use in Production.

Changelog
- Implement `subscription` type execition in the schema. 27
- Clearer lex errors for unprintable unicode.
- Introspection descriptions for scalar and introspection query types.
- Add missing tests. 23
- Implement [RFC] Additional optional arguments. 26
- Bump required gevent to `1.1rc1`.

Getting ready for stable release.

Changelog:
- [Executor] Implement memoization on `get_argument_values`.
- [Type Definition] Implement `__hash__` methods on `GraphQLField` and `GraphQLArgument`.
- [AST Visitor] Check if edit in visitor is a valid node.
- GraphQLUnion shall now accept a callable for types. This will make functionality equivalent to all the other types. i.e. GraphQLInterfaceType and GraphQLObjectType when it comes to defining fields/interfaces/types.

This is the first beta release of `graphql-core` and represents feature parity with [`graphql-js`](https://github.com/graphql/graphql-js/) `v0.4.7`, hence the matching version number. All `graphql-core` releases will follow `graphql-js` in terms of version numbers. This means for a given version of graphql-js, you can expect feature parity on the same version of `graphql-core`.

We will follow GraphQL's semantic versioning and releases except for one key difference, we will be introducing a BUGFIX version number as well, in the form of `MAJOR.MINOR.PATCH.BUGFIX`. This will allow us to match the PATCHes in graphql-js, while maintaining our own bugfix version numbers. That means that `v0.4.7.0`, `v0.4.7.1` will all match `v0.4.7` in feature parity, but with bugfixes to the Python codebase.

This release implements the Type Validation System (8)
- Implement type validation and unit tests 8
- Implement `assert_object_implements_interface` 8
- Implement missing enum_type tests.
- Removed submodule `libgraphqlparser`, move everything we need into `scripts`.
- Make `generate_ast` work on py3x
- Use **slots** in classes that seem to be instantiated a lot (to save some memory)

Yet again more potentially breaking fixes if you are using the Executor directly.
- Implement the `get_operation_ast` utility.
- Implement a way to get/set the default executor that is used when you call `graphql.core.graphql()` or `graphql.core.execute()`. You can do this by calling `graphql.core.executor.{get,set}_default_executor()`
- Add the option to specify `map_type` in the Executor. This change allows for you to specify what kind of Map you want to store your result data in. The two recommended options are:
- `dict` (the default). Use this when you don't care about result ordering. For example, you don't care that the order in the fields of your response match the order of the fields in your query. For most cases, this is correct and is the fastest option.
- [`collections.OrderedDict`](https://docs.python.org/2/library/collections.html#ordereddict-objects), when you pass something that is an OrderedDict, or a subclass of it, the executor will switch into "strict ordering" mode, which will make it so that the order of the results, match the order they were defined in the query. Concurrent execution will still execute out of order however if you are running a `Query` (but the results will still return in the correct order), you can override this by passing `execute_serially=True` to the executor (which is generally not needed. But exists incase you want to execute serially for whatever reason). Also, mutations will always execute serially.

You can use any other user implemented mapping type as long as it implements the [`MutableMapping`](https://docs.python.org/2/library/collections.html#collections.MutableMapping) abstract base type.
- The executor no longer takes `schema` in it's constructor. Instead pass this as the first argument to `Executor.execute()`.

More fixes and potentially breaking changes as we gradually implement schema type checking.
- The proper version of `gevent` can now be installed by using `pip install graphql-core[gevent]`.
- Require `six` as a dependency, and use it to handle py2/3 compat instead of `graphql.core.compat`.
- Ensure that values for `args` passed to `GraphQLField` are of type `GraphQLArgument`.
- Implement the `schema_printer` utility.
- Ensure that values for `fields` passed to `GraphQLInputType` are `GraphQLInputObjectFields`.
- For `GraphQLEnumType` use an `OrderedDict` to store values so that we can preserve the order of enums passed in. Additionally, when constructing an `GraphQLEnumType` you should use an OrderedDict to pass in your values as well. But this isn't enforced anywhere, but may raise a warning soon.
- Introspection's object types/enums should be using OrderedDicts for their fields/values, that way the order in the schema printer is going to be consistent.
- Switch argument ordering for `core.utils.value_from_ast` to match reference implementation.
- Allow `GraphQLInputObjectType` to take a callable as a `field` argument.
- Schema types should be built immediately instead of lazily when `get_type_map()` is called. This should allow us to raise exceptions upon construction of the schema, instead of later, upon first execution.
- Implement `build_ast_schema` utility.
- Split validation rules into individual files.
- The executor will now choose to use an ordered dict implementation when collecting the root fields of query/mutation, rather than an unordered-dict implementation to guarantee the order of execution when being executed serially is the same as it is defined in the query. No order guarantees are given for non-serial execution, as per the spec.
- Instead of using `is_nullish`, use a more Pythonic `is None` check. (thank you faassen)
- Remove `setup.py test` instead, use `tox` for testing.