Update mypy, use new semantic analyzer (#67)

Author: Cito

mypy.ini

@@ -3,5 +3,3 @@ python_version = 3.8
 check_untyped_defs = True
 warn_redundant_casts = True
 warn_unused_ignores = True
-# https://github.com/python/mypy/issues/7203
-new_semantic_analyzer = False

pyproject.toml

@@ -40,7 +40,7 @@ pytest-describe = ">=0.12"
 pyyaml = "^5.1"
 black = ">=19.10b0"
 flake8 = "^3.7"
-mypy = ">=0.720,<0.730"
+mypy = ">=0.750,<0.760"
 codecov = "^2"
 sphinx = "^2.2"
 sphinx_rtd_theme = ">=0.4"

src/graphql/execution/execute.py

@@ -34,7 +34,8 @@
     FrozenList,
     Path,
 )
-from ..utilities import get_operation_root_type, type_from_ast
+from ..utilities.get_operation_root_type import get_operation_root_type
+from ..utilities.type_from_ast import type_from_ast
 from ..type import (
     GraphQLAbstractType,
     GraphQLField,

src/graphql/execution/values.py

@@ -23,7 +23,9 @@
     is_input_type,
     is_non_null_type,
 )
-from ..utilities import coerce_input_value, type_from_ast, value_from_ast
+from ..utilities.coerce_input_value import coerce_input_value
+from ..utilities.type_from_ast import type_from_ast
+from ..utilities.value_from_ast import value_from_ast
 
 __all__ = ["get_variable_values", "get_argument_values", "get_directive_values"]
 

src/graphql/language/ast.py

@@ -239,7 +239,7 @@ def __init_subclass__(cls):
         keys: List[str] = []
         for base in cls.__bases__:
             # noinspection PyUnresolvedReferences
-            keys.extend(base.keys)
+            keys.extend(base.keys)  # type: ignore
         keys.extend(cls.__slots__)
         cls.keys = keys
 

src/graphql/language/visitor.py

@@ -5,6 +5,7 @@
     Callable,
     List,
     NamedTuple,
+    Optional,
     Sequence,
     Tuple,
     Union,
@@ -157,8 +158,11 @@ def __init_subclass__(cls):
         for attr, val in cls.__dict__.items():
             if attr.startswith("_"):
                 continue
-            attr = attr.split("_", 1)
-            attr, kind = attr if len(attr) > 1 else (attr[0], None)
+            attr_kind = attr.split("_", 1)
+            if len(attr_kind) < 2:
+                kind: Optional[str] = None
+            else:
+                attr, kind = attr_kind
             if attr in ("enter", "leave"):
                 if kind:
                     name = snake_to_camel(kind) + "Node"

src/graphql/subscription/map_async_iterator.py

@@ -1,7 +1,7 @@
-from asyncio import Event, ensure_future, wait
+from asyncio import Event, ensure_future, Future, wait
 from concurrent.futures import FIRST_COMPLETED
 from inspect import isasyncgen, isawaitable
-from typing import AsyncIterable, Callable
+from typing import AsyncIterable, Callable, Set
 
 __all__ = ["MapAsyncIterator"]
 
@@ -42,7 +42,9 @@ async def __anext__(self):
             aclose = ensure_future(self._close_event.wait())
             anext = ensure_future(self.iterator.__anext__())
 
-            done, pending = await wait([aclose, anext], return_when=FIRST_COMPLETED)
+            pending: Set[Future] = (
+                await wait([aclose, anext], return_when=FIRST_COMPLETED)
+            )[1]
             for task in pending:
                 task.cancel()
 

src/graphql/subscription/subscribe.py

@@ -62,7 +62,7 @@ async def subscribe(
     if isinstance(result_or_stream, ExecutionResult):
         return result_or_stream
 
-    async def map_source_to_response(payload):
+    async def map_source_to_response(payload) -> ExecutionResult:
         """Map source to response.
 
         For each payload yielded from a subscription, map it over the normal GraphQL
@@ -81,7 +81,7 @@ async def map_source_to_response(payload):
             operation_name,
             field_resolver,
         )
-        return await result if isawaitable(result) else result
+        return await result if isawaitable(result) else result  # type: ignore
 
     return MapAsyncIterator(result_or_stream, map_source_to_response)
 

src/graphql/type/definition.py

@@ -361,11 +361,11 @@ def __init__(
                 " as a sequence of ScalarTypeExtensionNode instances."
             )
         if serialize is not None:
-            self.serialize = serialize
+            self.serialize = serialize  # type: ignore
         if parse_value is not None:
-            self.parse_value = parse_value
+            self.parse_value = parse_value  # type: ignore
         if parse_literal is not None:
-            self.parse_literal = parse_literal
+            self.parse_literal = parse_literal  # type: ignore
 
     def __repr__(self):
         return f"<{self.__class__.__name__} {self.name!r}>"
@@ -391,9 +391,7 @@ def parse_value(value: Any) -> Any:
         """
         return value
 
-    def parse_literal(  # type: ignore
-        self, node: ValueNode, _variables: Dict[str, Any] = None
-    ) -> Any:
+    def parse_literal(self, node: ValueNode, _variables: Dict[str, Any] = None) -> Any:
         """Parses an externally provided literal value to use as an input.
 
         This default method uses the parse_value method and should be replaced
@@ -1247,7 +1245,7 @@ def __init__(
             )
         self._fields = fields
         if out_type is not None:
-            self.out_type = out_type
+            self.out_type = out_type  # type: ignore
 
     @staticmethod
     def out_type(value: Dict[str, Any]) -> Any:

src/graphql/type/validate.py

@@ -155,7 +155,7 @@ def validate_directives(self):
             arg_names: Set[str] = set()
             for arg_name, arg in directive.args.items():
                 # Ensure they are named correctly.
-                self.validate_name(arg_name, arg)
+                self.validate_name(arg, arg_name)
 
                 # Ensure they are unique per directive.
                 if arg_name in arg_names:

src/graphql/utilities/coerce_value.py

@@ -4,7 +4,7 @@
 from ..language import Node
 from ..pyutils import Path, inspect, print_path_list
 from ..type import GraphQLInputType
-from . import coerce_input_value
+from .coerce_input_value import coerce_input_value
 
 __all__ = ["coerce_value", "CoercedValue"]
 

src/graphql/utilities/extend_schema.py

@@ -169,8 +169,8 @@ def extend_named_type(type_: GraphQLNamedType) -> GraphQLNamedType:
 
     def extend_directive(directive: GraphQLDirective) -> GraphQLDirective:
         kwargs = directive.to_kwargs()
-        return GraphQLDirective(  # type: ignore
-            **{
+        return GraphQLDirective(
+            **{  # type: ignore
                 **kwargs,
                 "args": {name: extend_arg(arg) for name, arg in kwargs["args"].items()},
             }
@@ -188,8 +188,11 @@ def extend_input_object_type(
                 **kwargs,
                 "fields": lambda: {
                     **{
-                        name: GraphQLInputField(  # type: ignore
-                            **{**field.to_kwargs(), "type_": replace_type(field.type)}
+                        name: GraphQLInputField(
+                            **{  # type: ignore
+                                **field.to_kwargs(),
+                                "type_": replace_type(field.type),
+                            }
                         )
                         for name, field in kwargs["fields"].items()
                     },
@@ -306,17 +309,20 @@ def extend_union_type(type_: GraphQLUnionType) -> GraphQLUnionType:
         )
 
     def extend_field(field: GraphQLField) -> GraphQLField:
-        return GraphQLField(  # type: ignore
-            **{
+        return GraphQLField(
+            **{  # type: ignore
                 **field.to_kwargs(),
                 "type_": replace_type(field.type),
                 "args": {name: extend_arg(arg) for name, arg in field.args.items()},
             }
         )
 
     def extend_arg(arg: GraphQLArgument) -> GraphQLArgument:
-        return GraphQLArgument(  # type: ignore
-            **{**arg.to_kwargs(), "type_": replace_type(arg.type)}
+        return GraphQLArgument(
+            **{  # type: ignore
+                **arg.to_kwargs(),
+                "type_": replace_type(arg.type),
+            }
         )
 
     # noinspection PyShadowingNames
@@ -358,13 +364,17 @@ def resolve_type(type_name: str) -> GraphQLNamedType:
                 operation_types[operation] = operation_type.type.name.value
 
     # Then produce and return a Schema with these types.
-    return GraphQLSchema(  # type: ignore
+    return GraphQLSchema(
         # Note: While this could make early assertions to get the correctly
         # typed values, that would throw immediately while type system
         # validation with validateSchema() will produce more actionable results.
-        query=get_maybe_type_by_name(operation_types[OperationType.QUERY]),
-        mutation=get_maybe_type_by_name(operation_types[OperationType.MUTATION]),
-        subscription=get_maybe_type_by_name(
+        query=get_maybe_type_by_name(  # type: ignore
+            operation_types[OperationType.QUERY]
+        ),
+        mutation=get_maybe_type_by_name(  # type: ignore
+            operation_types[OperationType.MUTATION]
+        ),
+        subscription=get_maybe_type_by_name(  # type: ignore
             operation_types[OperationType.SUBSCRIPTION]
         ),
         types=list(type_map.values()),

src/graphql/utilities/find_breaking_changes.py

@@ -89,12 +89,11 @@ def find_breaking_changes(
     Given two schemas, returns a list containing descriptions of all the types of
     breaking changes covered by the other functions down below.
     """
-    breaking_changes = [
+    return [
         change
         for change in find_schema_changes(old_schema, new_schema)
         if isinstance(change.type, BreakingChangeType)
     ]
-    return cast(List[BreakingChange], breaking_changes)
 
 
 def find_dangerous_changes(
@@ -105,12 +104,11 @@ def find_dangerous_changes(
     Given two schemas, returns a list containing descriptions of all the types of
     potentially dangerous changes covered by the other functions down below.
     """
-    dangerous_changes = [
+    return [
         change
         for change in find_schema_changes(old_schema, new_schema)
         if isinstance(change.type, DangerousChangeType)
     ]
-    return cast(List[DangerousChange], dangerous_changes)
 
 
 def find_schema_changes(

src/graphql/utilities/separate_operations.py

@@ -52,14 +52,15 @@ def separate_operations(document_ast: DocumentNode) -> Dict[str, DocumentNode]:
     return separated_document_asts
 
 
+# noinspection PyAttributeOutsideInit
 class SeparateOperations(Visitor):
     def __init__(self):
         super().__init__()
         self.operations: List[OperationDefinitionNode] = []
         self.fragments: Dict[str, FragmentDefinitionNode] = {}
         self.positions: Dict[ExecutableDefinitionNode, int] = {}
         self.dep_graph: DepGraph = defaultdict(set)
-        self.from_name: str = None
+        self.from_name: str
         self.idx = 0
 
     def enter_operation_definition(self, node, *_args):

tests/execution/test_abstract.py

@@ -335,10 +335,10 @@ def resolve_type_on_union_yields_useful_error():
         }
 
     def returning_invalid_value_from_resolve_type_yields_useful_error():
-        foo_interface = GraphQLInterfaceType(  # type: ignore
+        foo_interface = GraphQLInterfaceType(
             "FooInterface",
             {"bar": GraphQLField(GraphQLString)},
-            resolve_type=lambda *_args: [],
+            resolve_type=lambda *_args: [],  # type: ignore
         )
 
         foo_object = GraphQLObjectType(

tests/execution/test_executor.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import cast
+from typing import cast, Awaitable
 
 from pytest import raises, mark  # type: ignore
 
@@ -84,10 +84,10 @@ def pic(self, _info, size=50):
                 return f"Pic of size: {size}"
 
             def deep(self, _info):
-                return DeepData()  # type: ignore
+                return DeepData()
 
             def promise(self, _info):
-                return promise_data()  # type: ignore
+                return promise_data()
 
         # noinspection PyMethodMayBeStatic,PyMethodMayBeStatic
         class DeepData:
@@ -134,7 +134,7 @@ async def promise_data():
                 "a": GraphQLField(GraphQLString),
                 "b": GraphQLField(GraphQLString),
                 "c": GraphQLField(GraphQLList(GraphQLString)),
-                "deeper": GraphQLList(DataType),
+                "deeper": GraphQLField(GraphQLList(DataType)),
             },
         )
 
@@ -170,9 +170,11 @@ async def promise_data():
             """
         )
 
-        result = await execute(
+        awaitable_result = execute(
             GraphQLSchema(DataType), document, Data(), variable_values={"size": 100}
         )
+        assert isinstance(awaitable_result, Awaitable)
+        result = await awaitable_result
 
         assert result == (
             {
@@ -411,7 +413,9 @@ async def asyncReturnErrorWithExtensions(self, _info):
                     extensions={"foo": "bar"},
                 )
 
-        result = await execute(schema, document, Data())
+        awaitable_result = execute(schema, document, Data())
+        assert isinstance(awaitable_result, Awaitable)
+        result = await awaitable_result
 
         assert result == (
             {
@@ -719,7 +723,9 @@ async def d(self, _info):
             def e(self, _info):
                 return "e"
 
-        result = await execute(schema, document, Data())
+        awaitable_result = execute(schema, document, Data())
+        assert isinstance(awaitable_result, Awaitable)
+        result = await awaitable_result
 
         assert result == ({"a": "a", "b": "b", "c": "c", "d": "d", "e": "e"}, None)
 
@@ -874,13 +880,14 @@ def uses_a_custom_type_resolver():
             types=[foo_object],
         )
 
+        possible_types = None
+
         def type_resolver(_source, info, abstract_type):
             # Resolver should be able to figure out all possible types on its own
             nonlocal possible_types
             possible_types = info.schema.get_possible_types(abstract_type)
             return "FooObject"
 
-        possible_types = None
         root_value = {"foo": {"bar": "bar"}}
         result = execute(schema, document, root_value, type_resolver=type_resolver)