Docs subscriptions and other housekeeping work (#65)

Author: KingDarBoja

.gitignore

@@ -56,6 +56,11 @@ coverage.xml
 # Django stuff:
 *.log
 
+# Type checking
+/.mypy_cache
+.pyre
+/type_info.json
+
 # Sphinx documentation
 docs/_build/
 
@@ -81,3 +86,6 @@ target/
 # Databases
 *.sqlite3
 .DS_Store
+
+### VisualStudioCode ###
+.vscode/*

.travis.yml

@@ -9,13 +9,23 @@ python:
   - 3.9-dev
   - pypy
   - pypy3
+matrix:
+  include:
+    - python: 3.6
+      env: TOXENV=flake8
+    - python: 3.6
+      env: TOXENV=black
+    - python: 3.6
+      env: TOXENV=import-order
+    - python: 3.6
+      env: TOXENV=mypy
+    - python: 3.6
+      env: TOXENV=manifest
 cache: pip
-install:
-  - pip install -e .[dev]
-script:
-  - flake8 gql tests
-  - pytest --cov-report=term-missing --cov=gql tests
+install: pip install tox-travis
+script: tox
 after_success:
+  - pip install coveralls
   - coveralls
 deploy:
   provider: pypi

CONTRIBUTING.md

@@ -31,7 +31,7 @@ virtualenv gql-dev
 Activate the virtualenv and install dependencies by running:
 
 ```console
-python pip install -e ".[test]"
+python pip install -e[dev]
 ```
 
 If you are using Linux or MacOS, you can make use of Makefile command 
@@ -50,7 +50,7 @@ Then activate the environment with `conda activate gql-dev`.
 Proceed to install all dependencies by running:
 
 ```console
-python pip install -e ".[test]"
+pip install -e.[dev]
 ```
 
 And you ready to start development!

MANIFEST.in

@@ -10,7 +10,8 @@ include Makefile
 
 include tox.ini
 
-recursive-include tests *.py *.yaml
+recursive-include tests *.py *.yaml *.graphql
+recursive-include tests_py36 *.py
 
 prune gql-checker
 

gql/__init__.py

@@ -1,4 +1,4 @@
 from .gql import gql
 from .client import Client
 
-__all__ = ['gql', 'Client']
+__all__ = ["gql", "Client"]

gql/client.py

@@ -1,6 +1,6 @@
 import logging
 
-from graphql import parse, introspection_query, build_ast_schema, build_client_schema
+from graphql import build_ast_schema, build_client_schema, introspection_query, parse
 from graphql.validation import validate
 
 from .transport.local_schema import LocalSchemaTransport
@@ -10,24 +10,38 @@
 
 class RetryError(Exception):
     """Custom exception thrown when retry logic fails"""
+
     def __init__(self, retries_count, last_exception):
         message = "Failed %s retries: %s" % (retries_count, last_exception)
         super(RetryError, self).__init__(message)
         self.last_exception = last_exception
 
 
 class Client(object):
-    def __init__(self, schema=None, introspection=None, type_def=None, transport=None,
-                 fetch_schema_from_transport=False, retries=0):
-        assert not(type_def and introspection), 'Cant provide introspection type definition at the same time'
+    def __init__(
+        self,
+        schema=None,
+        introspection=None,
+        type_def=None,
+        transport=None,
+        fetch_schema_from_transport=False,
+        retries=0,
+    ):
+        assert not (
+            type_def and introspection
+        ), "Cant provide introspection type definition at the same time"
         if transport and fetch_schema_from_transport:
-            assert not schema, 'Cant fetch the schema from transport if is already provided'
+            assert (
+                not schema
+            ), "Cant fetch the schema from transport if is already provided"
             introspection = transport.execute(parse(introspection_query)).data
         if introspection:
-            assert not schema, 'Cant provide introspection and schema at the same time'
+            assert not schema, "Cant provide introspection and schema at the same time"
             schema = build_client_schema(introspection)
         elif type_def:
-            assert not schema, 'Cant provide Type definition and schema at the same time'
+            assert (
+                not schema
+            ), "Cant provide Type definition and schema at the same time"
             type_def_ast = parse(type_def)
             schema = build_ast_schema(type_def_ast)
         elif schema and not transport:
@@ -40,7 +54,9 @@ def __init__(self, schema=None, introspection=None, type_def=None, transport=Non
 
     def validate(self, document):
         if not self.schema:
-            raise Exception("Cannot validate locally the document, you need to pass a schema.")
+            raise Exception(
+                "Cannot validate locally the document, you need to pass a schema."
+            )
         validation_errors = validate(self.schema, document)
         if validation_errors:
             raise validation_errors[0]
@@ -67,8 +83,12 @@ def _get_result(self, document, *args, **kwargs):
                 return result
             except Exception as e:
                 last_exception = e
-                log.warning("Request failed with exception %s. Retrying for the %s time...",
-                            e, retries_count + 1, exc_info=True)
+                log.warning(
+                    "Request failed with exception %s. Retrying for the %s time...",
+                    e,
+                    retries_count + 1,
+                    exc_info=True,
+                )
             finally:
                 retries_count += 1
 

gql/dsl.py

@@ -3,7 +3,13 @@
 import six
 from graphql.language import ast
 from graphql.language.printer import print_ast
-from graphql.type import (GraphQLEnumType, GraphQLList, GraphQLNonNull)
+from graphql.type import (
+    GraphQLEnumType,
+    GraphQLInputObjectField,
+    GraphQLInputObjectType,
+    GraphQLList,
+    GraphQLNonNull,
+)
 from graphql.utils.ast_from_value import ast_from_value
 
 from .utils import to_camel_case
@@ -30,7 +36,7 @@ def query(self, *args, **kwargs):
         return self.execute(query(*args, **kwargs))
 
     def mutate(self, *args, **kwargs):
-        return self.query(*args, operation='mutation', **kwargs)
+        return self.query(*args, operation="mutation", **kwargs)
 
     def execute(self, document):
         return self.client.execute(document)
@@ -53,7 +59,9 @@ def get_field(self, name):
         if camel_cased_name in self.type.fields:
             return camel_cased_name, self.type.fields[camel_cased_name]
 
-        raise KeyError('Field {} does not exist in type {}.'.format(name, self.type.name))
+        raise KeyError(
+            "Field {} does not exist in type {}.".format(name, self.type.name)
+        )
 
 
 def selections(*fields):
@@ -62,7 +70,6 @@ def selections(*fields):
 
 
 class DSLField(object):
-
     def __init__(self, name, field):
         self.field = field
         self.ast_field = ast.Field(name=ast.Name(value=name), arguments=[])
@@ -87,10 +94,7 @@ def args(self, **kwargs):
             arg_type_serializer = get_arg_serializer(arg.type)
             serialized_value = arg_type_serializer(value)
             self.ast_field.arguments.append(
-                ast.Argument(
-                    name=ast.Name(value=name),
-                    value=serialized_value
-                )
+                ast.Argument(name=ast.Name(value=name), value=serialized_value)
             )
         return self
 
@@ -110,26 +114,38 @@ def selection_field(field):
 
 
 def query(*fields, **kwargs):
-    if 'operation' not in kwargs:
-        kwargs['operation'] = 'query'
+    if "operation" not in kwargs:
+        kwargs["operation"] = "query"
     return ast.Document(
-        definitions=[ast.OperationDefinition(
-            operation=kwargs['operation'],
-            selection_set=ast.SelectionSet(
-                selections=list(selections(*fields))
+        definitions=[
+            ast.OperationDefinition(
+                operation=kwargs["operation"],
+                selection_set=ast.SelectionSet(selections=list(selections(*fields))),
             )
-        )]
+        ]
     )
 
 
 def serialize_list(serializer, list_values):
-    assert isinstance(list_values, Iterable), 'Expected iterable, received "{}"'.format(repr(list_values))
+    assert isinstance(list_values, Iterable), 'Expected iterable, received "{}"'.format(
+        repr(list_values)
+    )
     return ast.ListValue(values=[serializer(v) for v in list_values])
 
 
 def get_arg_serializer(arg_type):
     if isinstance(arg_type, GraphQLNonNull):
         return get_arg_serializer(arg_type.of_type)
+    if isinstance(arg_type, GraphQLInputObjectField):
+        return get_arg_serializer(arg_type.type)
+    if isinstance(arg_type, GraphQLInputObjectType):
+        serializers = {k: get_arg_serializer(v) for k, v in arg_type.fields.items()}
+        return lambda value: ast.ObjectValue(
+            fields=[
+                ast.ObjectField(ast.Name(k), serializers[k](v))
+                for k, v in value.items()
+            ]
+        )
     if isinstance(arg_type, GraphQLList):
         inner_serializer = get_arg_serializer(arg_type.of_type)
         return partial(serialize_list, inner_serializer)

gql/gql.py

@@ -5,7 +5,7 @@
 
 def gql(request_string):
     if isinstance(request_string, six.string_types):
-        source = Source(request_string, 'GraphQL request')
+        source = Source(request_string, "GraphQL request")
         return parse(source)
     else:
         raise Exception('Received incompatible request "{}".'.format(request_string))

gql/transport/__init__.py

@@ -17,4 +17,6 @@ def execute(self, document):
         :param document: GraphQL query as AST Node or Document object.
         :return: Either ExecutionResult or a Promise that resolves to ExecutionResult object.
         """
-        raise NotImplementedError("Any Transport subclass must implement execute method")
+        raise NotImplementedError(
+            "Any Transport subclass must implement execute method"
+        )

gql/transport/local_schema.py

@@ -1,18 +1,18 @@
-from typing import Union, Any
-
 from graphql import GraphQLSchema
-from graphql.execution import execute, ExecutionResult
+from graphql.execution import ExecutionResult, execute
 from graphql.language.ast import Document
 from promise import Promise
 
 from gql.transport import Transport
+from typing import Any, Union
 
 
 class LocalSchemaTransport(Transport):
     """A transport for executing GraphQL queries against a local schema."""
+
     def __init__(
         self,  # type: LocalSchemaTransport
-        schema  # type: GraphQLSchema
+        schema,  # type: GraphQLSchema
     ):
         """Initialize the transport with the given local schema.
 
@@ -29,9 +29,4 @@ def execute(self, document, *args, **kwargs):
         :param kwargs: Keyword options passed to execute method from graphql-core library.
         :return: Either ExecutionResult or a Promise that resolves to ExecutionResult object.
         """
-        return execute(
-            self.schema,
-            document,
-            *args,
-            **kwargs
-        )
+        return execute(self.schema, document, *args, **kwargs)