Fix issues with newer mypy version

Author: Cito

Diff for: src/graphql/execution/execute.py

@@ -10,9 +10,9 @@
     Iterable,
     List,
     Optional,
-    Union,
     Tuple,
     Type,
+    Union,
     cast,
 )
 
@@ -30,25 +30,27 @@
     OperationType,
 )
 from ..pyutils import (
-    inspect,
-    is_awaitable as default_is_awaitable,
-    is_iterable,
     AwaitableOrValue,
     Path,
     Undefined,
+    inspect,
+    is_iterable,
+)
+from ..pyutils import (
+    is_awaitable as default_is_awaitable,
 )
 from ..type import (
     GraphQLAbstractType,
     GraphQLField,
+    GraphQLFieldResolver,
     GraphQLLeafType,
     GraphQLList,
     GraphQLNonNull,
     GraphQLObjectType,
     GraphQLOutputType,
+    GraphQLResolveInfo,
     GraphQLSchema,
-    GraphQLFieldResolver,
     GraphQLTypeResolver,
-    GraphQLResolveInfo,
     SchemaMetaFieldDef,
     TypeMetaFieldDef,
     TypeNameMetaFieldDef,
@@ -213,13 +215,13 @@ def __init__(
         self.context_value = context_value
         self.operation = operation
         self.variable_values = variable_values
-        self.field_resolver = field_resolver  # type: ignore
-        self.type_resolver = type_resolver  # type: ignore
-        self.subscribe_field_resolver = subscribe_field_resolver  # type: ignore
+        self.field_resolver = field_resolver
+        self.type_resolver = type_resolver
+        self.subscribe_field_resolver = subscribe_field_resolver
         self.errors = errors
         self.middleware_manager = middleware_manager
         if is_awaitable:
-            self.is_awaitable = is_awaitable
+            self.is_awaitable = is_awaitable  # type: ignore
         self._subfields_cache: Dict[Tuple, Dict[str, List[FieldNode]]] = {}
 
     @classmethod
@@ -793,7 +795,7 @@ def complete_abstract_value(
         that value, then complete the value for that type.
         """
         resolve_type_fn = return_type.resolve_type or self.type_resolver
-        runtime_type = resolve_type_fn(result, info, return_type)  # type: ignore
+        runtime_type = resolve_type_fn(result, info, return_type)
 
         if self.is_awaitable(runtime_type):
             runtime_type = cast(Awaitable, runtime_type)
@@ -1096,10 +1098,10 @@ def execute_sync(
 
     # Assert that the execution was synchronous.
     if isawaitable(result):
-        ensure_future(cast(Awaitable[ExecutionResult], result)).cancel()
+        ensure_future(result).cancel()
         raise RuntimeError("GraphQL execution failed to complete synchronously.")
 
-    return cast(ExecutionResult, result)
+    return result
 
 
 def assert_valid_execution_arguments(

Diff for: src/graphql/graphql.py

@@ -1,10 +1,10 @@
 from asyncio import ensure_future
 from inspect import isawaitable
-from typing import Any, Awaitable, Callable, Dict, Optional, Union, Type, cast
+from typing import Any, Callable, Dict, Optional, Type, Union
 
 from .error import GraphQLError
-from .execution import execute, ExecutionResult, ExecutionContext, Middleware
-from .language import parse, Source
+from .execution import ExecutionContext, ExecutionResult, Middleware, execute
+from .language import Source, parse
 from .pyutils import AwaitableOrValue
 from .type import (
     GraphQLFieldResolver,
@@ -90,9 +90,9 @@ async def graphql(
     )
 
     if isawaitable(result):
-        return await cast(Awaitable[ExecutionResult], result)
+        return await result
 
-    return cast(ExecutionResult, result)
+    return result
 
 
 def assume_not_awaitable(_value: Any) -> bool:
@@ -143,10 +143,10 @@ def graphql_sync(
 
     # Assert that the execution was synchronous.
     if isawaitable(result):
-        ensure_future(cast(Awaitable[ExecutionResult], result)).cancel()
+        ensure_future(result).cancel()
         raise RuntimeError("GraphQL execution failed to complete synchronously.")
 
-    return cast(ExecutionResult, result)
+    return result
 
 
 def graphql_impl(

Diff for: src/graphql/pyutils/frozen_dict.py

@@ -6,7 +6,7 @@
 __all__ = ["FrozenDict"]
 
 KT = TypeVar("KT")
-VT = TypeVar("VT", covariant=True)
+VT = TypeVar("VT")
 
 
 class FrozenDict(Dict[KT, VT]):
@@ -25,7 +25,7 @@ def __setitem__(self, key, value):
     def __iadd__(self, value):
         raise FrozenError
 
-    def __hash__(self):
+    def __hash__(self) -> int:  # type: ignore
         return hash(tuple(self.items()))
 
     def __copy__(self) -> "FrozenDict":
@@ -48,5 +48,5 @@ def popitem(self):
     def setdefault(self, key, default=None):
         raise FrozenError
 
-    def update(self, other=None):
+    def update(self, other=None):  # type: ignore
         raise FrozenError

Diff for: src/graphql/pyutils/frozen_list.py

@@ -6,7 +6,7 @@
 __all__ = ["FrozenList"]
 
 
-T = TypeVar("T", covariant=True)
+T = TypeVar("T")
 
 
 class FrozenList(List[T]):
@@ -36,7 +36,7 @@ def __mul__(self, value):
     def __imul__(self, value):
         raise FrozenError
 
-    def __hash__(self):
+    def __hash__(self) -> int:  # type: ignore
         return hash(tuple(self))
 
     def __copy__(self) -> "FrozenList":

Diff for: src/graphql/type/definition.py

@@ -833,8 +833,10 @@ def fields(self) -> GraphQLFieldMap:
             )
         return {
             assert_name(name): (
-                value if isinstance(value, GraphQLField) else GraphQLField(value)
-            )  # type: ignore
+                value
+                if isinstance(value, GraphQLField)
+                else GraphQLField(value)  # type: ignore
+            )
             for name, value in fields.items()
         }
 
@@ -967,8 +969,10 @@ def fields(self) -> GraphQLFieldMap:
             )
         return {
             assert_name(name): (
-                value if isinstance(value, GraphQLField) else GraphQLField(value)
-            )  # type: ignore
+                value
+                if isinstance(value, GraphQLField)
+                else GraphQLField(value)  # type: ignore
+            )
             for name, value in fields.items()
         }
 
@@ -1175,12 +1179,12 @@ def __init__(
             ):
                 try:
                     # noinspection PyTypeChecker
-                    values = dict(values)  # type: ignore
-                except (TypeError, ValueError):
+                    values = dict(values)
+                except (TypeError, ValueError) as error:
                     raise TypeError(
                         f"{name} values must be an Enum or a mapping"
                         " with value names as keys."
-                    )
+                    ) from error
             values = cast(Dict[str, Any], values)
         else:
             values = cast(Dict[str, Enum], values)
@@ -1488,8 +1492,8 @@ def fields(self) -> GraphQLInputFieldMap:
             assert_name(name): (
                 value
                 if isinstance(value, GraphQLInputField)
-                else GraphQLInputField(value)
-            )  # type: ignore
+                else GraphQLInputField(value)  # type: ignore
+            )
             for name, value in fields.items()
         }
 

Diff for: src/graphql/validation/validate.py

@@ -2,8 +2,8 @@
 
 from ..error import GraphQLError
 from ..language import DocumentNode, ParallelVisitor, visit
-from ..type import GraphQLSchema, assert_valid_schema
 from ..pyutils import inspect, is_collection
+from ..type import GraphQLSchema, assert_valid_schema
 from ..utilities import TypeInfo, TypeInfoVisitor
 from .rules import ASTValidationRule
 from .specified_rules import specified_rules, specified_sdl_rules
@@ -65,7 +65,7 @@ def validate(
     errors: List[GraphQLError] = []
 
     def on_error(error: GraphQLError) -> None:
-        if len(errors) >= max_errors:  # type: ignore
+        if len(errors) >= max_errors:
             errors.append(
                 GraphQLError(
                     "Too many validation errors, error limit reached."

Diff for: tests/execution/test_map_async_iterator.py

@@ -8,7 +8,7 @@
 is_pypy = platform.python_implementation() == "PyPy"
 
 try:  # pragma: no cover
-    anext
+    anext  # type: ignore
 except NameError:  # pragma: no cover (Python < 3.10)
     # noinspection PyShadowingBuiltins
     async def anext(iterator):

Diff for: tests/execution/test_subscribe.py

@@ -1,9 +1,7 @@
 import asyncio
+from typing import Any, Callable, Dict, List
 
-from typing import Any, Dict, List, Callable
-
-from pytest import mark, raises
-
+from graphql.execution import MapAsyncIterator, create_source_event_stream, subscribe
 from graphql.language import parse
 from graphql.pyutils import SimplePubSub
 from graphql.type import (
@@ -16,10 +14,10 @@
     GraphQLSchema,
     GraphQLString,
 )
-from graphql.execution import create_source_event_stream, subscribe, MapAsyncIterator
+from pytest import mark, raises
 
 try:
-    anext
+    anext  # type: ignore
 except NameError:  # pragma: no cover (Python < 3.10)
     # noinspection PyShadowingBuiltins
     async def anext(iterator):

Diff for: tests/test_user_registry.py

@@ -15,12 +15,7 @@
 except ImportError:  # Python < 3.7
     create_task = None  # type: ignore
 
-from pytest import fixture, mark
-
 from graphql import (
-    graphql,
-    parse,
-    subscribe,
     GraphQLArgument,
     GraphQLBoolean,
     GraphQLEnumType,
@@ -33,10 +28,13 @@
     GraphQLObjectType,
     GraphQLSchema,
     GraphQLString,
+    graphql,
+    parse,
+    subscribe,
 )
-
-from graphql.pyutils import SimplePubSub, SimplePubSubIterator
 from graphql.execution.map_async_iterator import MapAsyncIterator
+from graphql.pyutils import SimplePubSub, SimplePubSubIterator
+from pytest import fixture, mark
 
 
 class User(NamedTuple):
@@ -498,22 +496,23 @@ async def mutate_users():
             )
 
         async def receive_one():
-            async for result in subscription_one:  # type: ignore # pragma: no cover
+            async for result in subscription_one:  # pragma: no cover
                 received_one.append(result)
                 if len(received_one) == 3:  # pragma: no cover else
                     break
 
         async def receive_all():
-            async for result in subscription_all:  # type: ignore # pragma: no cover
+            async for result in subscription_all:  # pragma: no cover
                 received_all.append(result)
                 if len(received_all) == 6:  # pragma: no cover else
                     break
 
         tasks = [
-            create_task(task()) if create_task else task()
+            create_task(task()) if create_task else task()  # type: ignore
             for task in (mutate_users, receive_one, receive_all)
         ]
         done, pending = await wait(tasks, timeout=1)
+        assert len(done) == len(tasks)
         assert not pending
 
         expected_data: List[Dict[str, Any]] = [