Clean-up, reduce line lengths to 88 (used by black)

Author: Cito

gql-checker/gql_checker/__init__.py

@@ -76,7 +76,7 @@ def get_schema(self):
                     introspection_schema = json.load(data_file)
                     return build_client_schema(introspection_schema)
             except IOError as e:
-                raise Exception("Cannot find the provided introspection schema. {}".format(str(e)))
+                raise Exception(f"Cannot find the provided introspection schema. {e}")
 
         schema = self.options.get('schema')
         assert schema, 'Need to provide schema'

gql-checker/gql_checker/flake8_linter.py

@@ -43,7 +43,7 @@ def parse_options(cls, options):
 
     def error(self, node, code, message):
         lineno, col_offset = node.lineno, node.col_offset
-        return (lineno, col_offset, '{0} {1}'.format(code, message), Linter)
+        return lineno, col_offset, f'{code} {message}', Linter
 
     def run(self):
         for error in self.check_gql():

gql/client.py

@@ -1,4 +1,5 @@
 import asyncio
+from inspect import isawaitable
 from typing import Any, AsyncGenerator, Dict, Generator, Optional, Union, cast
 
 from graphql import (
@@ -87,16 +88,18 @@ def execute(self, document: DocumentNode, *args, **kwargs) -> Dict:
         This function WILL BLOCK until the result is received from the server.
 
         Either the transport is sync and we execute the query synchronously directly
-        OR the transport is async and we execute the query in the asyncio loop (blocking here until answer)
+        OR the transport is async and we execute the query in the asyncio loop
+        (blocking here until answer).
         """
 
         if isinstance(self.transport, AsyncTransport):
 
             loop = asyncio.get_event_loop()
 
-            assert (
-                not loop.is_running()
-            ), "Cannot run client.execute if an asyncio loop is running. Use execute_async instead"
+            assert not loop.is_running(), (
+                "Cannot run client.execute if an asyncio loop is running."
+                " Use execute_async instead."
+            )
 
             data: Dict[Any, Any] = loop.run_until_complete(
                 self.execute_async(document, *args, **kwargs)
@@ -109,9 +112,12 @@ def execute(self, document: DocumentNode, *args, **kwargs) -> Dict:
             if self.schema:
                 self.validate(document)
 
-            assert self.transport is not None, "Cant execute without a tranport"
+            assert self.transport is not None, "Cannot execute without a transport"
+
+            result = self.transport.execute(document, *args, **kwargs)
 
-            result: ExecutionResult = self.transport.execute(document, *args, **kwargs)
+            assert not isawaitable(result), "Transport returned an awaitable result."
+            result = cast(ExecutionResult, result)
 
             if result.errors:
                 raise TransportQueryError(str(result.errors[0]))
@@ -146,9 +152,10 @@ def subscribe(
 
         loop = asyncio.get_event_loop()
 
-        assert (
-            not loop.is_running()
-        ), "Cannot run client.subscribe if an asyncio loop is running. Use subscribe_async instead"
+        assert not loop.is_running(), (
+            "Cannot run client.subscribe if an asyncio loop is running."
+            " Use subscribe_async instead."
+        )
 
         try:
             while True:
@@ -191,15 +198,20 @@ def __exit__(self, *args):
 
 
 class ClientSession:
-    """ An instance of this class is created when using 'async with' on the client.
+    """An instance of this class is created when using 'async with' on the client.
 
-    It contains the async methods (execute, subscribe) to send queries with the async transports"""
+    It contains the async methods (execute, subscribe) to send queries
+    with the async transports.
+    """
 
     def __init__(self, client: Client):
         self.client = client
 
     async def validate(self, document: DocumentNode):
-        """ Fetch schema from transport if needed and validate document if schema is present """
+        """Fetch schema from transport if needed and validate document.
+
+        If no schema is present, the validation will be skipped.
+        """
 
         # Get schema from transport if needed
         if self.client.fetch_schema_from_transport and not self.client.schema:
@@ -213,7 +225,7 @@ async def subscribe(
         self, document: DocumentNode, *args, **kwargs
     ) -> AsyncGenerator[Dict, None]:
 
-        # Fetch schema from transport if needed and validate document if schema is present
+        # Fetch schema from transport if needed and validate document if possible
         await self.validate(document)
 
         # Subscribe to the transport and yield data or raise error
@@ -224,7 +236,7 @@ async def subscribe(
         async for result in self._generator:
             if result.errors:
                 # Note: we need to run generator.aclose() here or the finally block in
-                # the transport.subscribe will not be reached in pypy3 (python version 3.6.1)
+                # transport.subscribe will not be reached in pypy3 (py 3.6.1)
                 await self._generator.aclose()
 
                 raise TransportQueryError(str(result.errors[0]))
@@ -234,7 +246,7 @@ async def subscribe(
 
     async def execute(self, document: DocumentNode, *args, **kwargs) -> Dict:
 
-        # Fetch schema from transport if needed and validate document if schema is present
+        # Fetch schema from transport if needed and validate document if possible
         await self.validate(document)
 
         # Execute the query with the transport with a timeout

gql/dsl.py

@@ -65,9 +65,7 @@ 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(f"Field {name} does not exist in type {self.type.name}.")
 
 
 def selections(*fields):
@@ -126,7 +124,7 @@ def selection_field(field):
     if isinstance(field, DSLField):
         return field
 
-    raise Exception('Received incompatible query field: "{}".'.format(field))
+    raise Exception(f'Received incompatible query field: "{field}".')
 
 
 def query(*fields, **kwargs):
@@ -145,9 +143,9 @@ def query(*fields, **kwargs):
 
 
 def serialize_list(serializer, list_values):
-    assert isinstance(list_values, Iterable), 'Expected iterable, received "{}"'.format(
-        repr(list_values)
-    )
+    assert isinstance(
+        list_values, Iterable
+    ), f'Expected iterable, received "{list_values!r}".'
     return ListValueNode(values=FrozenList(serializer(v) for v in list_values))
 
 

gql/transport/aiohttp.py

@@ -42,7 +42,7 @@ def __init__(
         :param cookies: Dict of HTTP cookies.
         :param auth: BasicAuth object to enable Basic HTTP auth if needed
         :param ssl: ssl_context of the connection. Use ssl=False to disable encryption
-        :param client_session_args: Dict of extra parameters passed to aiohttp.ClientSession
+        :param client_session_args: Dict of extra args passed to aiohttp.ClientSession
         """
         self.url: str = url
         self.headers: Optional[LooseHeaders] = headers
@@ -96,9 +96,10 @@ async def execute(
         extra_args: Dict[str, Any] = {},
     ) -> ExecutionResult:
         """Execute the provided document AST against the configured remote server.
-        This uses the aiohttp library to perform a HTTP POST request asynchronously to the remote server.
+        This uses the aiohttp library to perform a HTTP POST request asynchronously
+        to the remote server.
 
-        The result is sent as an ExecutionResult object
+        The result is sent as an ExecutionResult object.
         """
 
         query_str = print_ast(document)
@@ -126,7 +127,7 @@ async def execute(
                 # We raise a TransportProtocolError in the other cases
 
                 try:
-                    # Raise a ClientResponseError if the response status is 400 or higher
+                    # Raise a ClientResponseError if response status is 400 or higher
                     resp.raise_for_status()
 
                 except ClientResponseError as e:

gql/transport/exceptions.py

@@ -3,20 +3,23 @@ class TransportError(Exception):
 
 
 class TransportProtocolError(TransportError):
-    """ An answer received from the server does not correspond to the transport protocol"""
+    """Transport protocol error.
+
+    The answer received from the server does not correspond to the transport protocol.
+    """
 
 
 class TransportServerError(TransportError):
-    """ The server returned a global error
+    """The server returned a global error.
 
-    This exception will close the transport connection
+    This exception will close the transport connection.
     """
 
 
 class TransportQueryError(Exception):
-    """ The server returned an error for a specific query
+    """The server returned an error for a specific query.
 
-    This exception should not close the transport connection
+    This exception should not close the transport connection.
     """
 
     def __init__(self, msg, query_id=None):
@@ -25,10 +28,16 @@ def __init__(self, msg, query_id=None):
 
 
 class TransportClosed(TransportError):
-    """ Exception generated when the client is trying to use the transport
-    while the transport was previously closed """
+    """Transport is already closed.
+
+    This exception is generated when the client is trying to use the transport
+    while the transport was previously closed.
+    """
 
 
 class TransportAlreadyConnected(TransportError):
-    """ Exception generated when the client is trying to connect to the transport
-    while the transport is already connected """
+    """Transport is already connected.
+
+    Exception generated when the client is trying to connect to the transport
+    while the transport is already connected.
+    """

gql/transport/local_schema.py

@@ -1,3 +1,5 @@
+from typing import Awaitable, Union
+
 from graphql import DocumentNode, ExecutionResult, GraphQLSchema, execute
 
 from gql.transport import Transport
@@ -15,12 +17,14 @@ def __init__(
         """
         self.schema = schema
 
-    def execute(self, document: DocumentNode, *args, **kwargs) -> ExecutionResult:
+    def execute(
+        self, document: DocumentNode, *args, **kwargs
+    ) -> Union[ExecutionResult, Awaitable[ExecutionResult]]:
         """Execute the given document against the configured local schema.
 
         :param document: GraphQL query as AST Node object.
-        :param args: Positional options for execute method from graphql-core library.
-        :param kwargs: Keyword options passed to execute method from graphql-core library.
-        :return: Either ExecutionResult or a Promise that resolves to ExecutionResult object.
+        :param args: Positional options for execute method from graphql-core.
+        :param kwargs: Keyword options passed to execute method from graphql-core.
+        :return: ExecutionResult (either as value or awaitable)
         """
-        return execute(self.schema, document, *args, **kwargs)  # type: ignore
+        return execute(self.schema, document, *args, **kwargs)

gql/transport/requests.py

@@ -16,33 +16,37 @@ class RequestsHTTPTransport(Transport):
     """
 
     def __init__(
-        self,  # type: RequestsHTTPTransport
-        url,  # type: str
-        headers=None,  # type: Dict[str, Any]
-        cookies=None,  # type: Union[Dict[str, Any], RequestsCookieJar]
-        auth=None,  # type: AuthBase
-        use_json=True,  # type: bool
-        timeout=None,  # type: int
-        verify=True,  # type: bool
-        retries=0,  # type: int
-        method="POST",  # type: str
-        **kwargs  # type: Any
+        self,
+        url: str,
+        headers: Optional[Dict[str, Any]] = None,
+        cookies: Optional[Union[Dict[str, Any], RequestsCookieJar]] = None,
+        auth: Optional[AuthBase] = None,
+        use_json: bool = True,
+        timeout: Optional[int] = None,
+        verify: bool = True,
+        retries: int = 0,
+        method: str = "POST",
+        **kwargs: Any
     ):
         """Initialize the transport with the given request parameters.
 
         :param url: The GraphQL server URL.
-        :param headers: Dictionary of HTTP Headers to send with the :class:`Request` (Default: None).
-        :param cookies: Dict or CookieJar object to send with the :class:`Request` (Default: None).
-        :param auth: Auth tuple or callable to enable Basic/Digest/Custom HTTP Auth (Default: None).
-        :param use_json: Send request body as JSON instead of form-urlencoded (Default: False).
+        :param headers: Dictionary of HTTP Headers to send with the :class:`Request`
+            (Default: None).
+        :param cookies: Dict or CookieJar object to send with the :class:`Request`
+            (Default: None).
+        :param auth: Auth tuple or callable to enable Basic/Digest/Custom HTTP Auth
+            (Default: None).
+        :param use_json: Send request body as JSON instead of form-urlencoded
+            (Default: True).
         :param timeout: Specifies a default timeout for requests (Default: None).
         :param verify: Either a boolean, in which case it controls whether we verify
             the server's TLS certificate, or a string, in which case it must be a path
             to a CA bundle to use. (Default: True).
         :param retries: Pre-setup of the requests' Session for performing retries
         :param method: HTTP method used for requests. (Default: POST).
-        :param kwargs: Optional arguments that ``request`` takes. These can be seen at the :requests_: source code
-            or the official :docs_:
+        :param kwargs: Optional arguments that ``request`` takes.
+            These can be seen at the :requests_: source code or the official :docs_:
 
         .. _requests: https://github.com/psf/requests/blob/master/requests/api.py
         .. _docs: https://requests.readthedocs.io/en/master/
@@ -78,14 +82,17 @@ def execute(  # type: ignore
         variable_values: Optional[Dict[str, Any]] = None,
         timeout: Optional[int] = None,
     ) -> ExecutionResult:
-        """Execute the provided document AST against the configured remote server.
-        This uses the requests library to perform a HTTP POST request to the remote server.
+        """Execute GraphQL query.
+
+        Execute the provided document AST against the configured remote server. This
+        uses the requests library to perform a HTTP POST request to the remote server.
 
         :param document: GraphQL query as AST Node object.
         :param variable_values: Dictionary of input parameters (Default: None).
         :param timeout: Specifies a default timeout for requests (Default: None).
-        :return: The result of execution. `data` is the result of executing the query, `errors` is null if no errors
-            occurred, and is a non-empty array if an error occurred.
+        :return: The result of execution.
+            `data` is the result of executing the query, `errors` is null
+            if no errors occurred, and is a non-empty array if an error occurred.
         """
         query_str = print_ast(document)
         payload = {"query": query_str, "variables": variable_values or {}}
@@ -104,7 +111,9 @@ def execute(  # type: ignore
         post_args.update(self.kwargs)
 
         # Using the created session to perform requests
-        response = self.session.request(self.method, self.url, **post_args)  # type: ignore
+        response = self.session.request(
+            self.method, self.url, **post_args  # type: ignore
+        )
         try:
             result = response.json()
             if not isinstance(result, dict):

gql/transport/transport.py

@@ -1,15 +1,20 @@
 import abc
+from typing import Awaitable, Union
 
 from graphql import DocumentNode, ExecutionResult
 
 
 class Transport:
     @abc.abstractmethod
-    def execute(self, document: DocumentNode, *args, **kwargs) -> ExecutionResult:
-        """Execute the provided document AST for either a remote or local GraphQL Schema.
+    def execute(
+        self, document: DocumentNode, *args, **kwargs
+    ) -> Union[ExecutionResult, Awaitable[ExecutionResult]]:
+        """Execute GraphQL query.
+
+        Execute the provided document AST for either a remote or local GraphQL Schema.
 
         :param document: GraphQL query as AST Node or Document object.
-        :return: Either ExecutionResult or a Promise that resolves to ExecutionResult object.
+        :return: ExecutionResult (either as value or awaitable)
         """
         raise NotImplementedError(
             "Any Transport subclass must implement execute method"
@@ -18,8 +23,8 @@ def execute(self, document: DocumentNode, *args, **kwargs) -> ExecutionResult:
     def close(self):
         """Close the transport
 
-        This method doesn't have to be implemented unless the transport would benefit from it.
-        This is currently used by the RequestsHTTPTransport transport to close the session's
-        connection pool.
+        This method doesn't have to be implemented unless the transport would benefit
+        from it. This is currently used by the RequestsHTTPTransport transport to close
+        the session's connection pool.
         """
         pass