Extend type checks to functions without type annotations

Author: Cito

mypy.ini

@@ -1,6 +1,7 @@
 [mypy]
 python_version = 3.7
-warn_redundant_casts = true
+check_untyped_defs = True
+warn_redundant_casts = True
 warn_unused_ignores = True
 # https://github.com/python/mypy/issues/7203
 new_semantic_analyzer = False

src/graphql/execution/execute.py

@@ -306,7 +306,7 @@ def build_response(
         if isawaitable(data):
 
             async def build_response_async():
-                return self.build_response(await data)
+                return self.build_response(await data)  # type: ignore
 
             return build_response_async()
         data = cast(Optional[Dict[str, Any]], data)
@@ -353,7 +353,7 @@ def execute_operation(
                 # noinspection PyShadowingNames
                 async def await_result():
                     try:
-                        return await result
+                        return await result  # type: ignore
                     except GraphQLError as error:
                         self.errors.append(error)
                     except Exception as error:
@@ -872,15 +872,19 @@ def complete_abstract_value(
             async def await_complete_object_value():
                 value = self.complete_object_value(
                     self.ensure_valid_runtime_type(
-                        await runtime_type, return_type, field_nodes, info, result
+                        await runtime_type,  # type: ignore
+                        return_type,
+                        field_nodes,
+                        info,
+                        result,
                     ),
                     field_nodes,
                     info,
                     path,
                     result,
                 )
                 if isawaitable(value):
-                    return await value
+                    return await value  # type: ignore
                 return value
 
             return await_complete_object_value()
@@ -950,7 +954,7 @@ def complete_object_value(
             if isawaitable(is_type_of):
 
                 async def collect_and_execute_subfields_async():
-                    if not await is_type_of:
+                    if not await is_type_of:  # type: ignore
                         raise invalid_return_type_error(
                             return_type, result, field_nodes
                         )

src/graphql/language/ast.py

@@ -1,6 +1,6 @@
 from copy import copy, deepcopy
 from enum import Enum
-from typing import NamedTuple, Optional, Union
+from typing import List, NamedTuple, Optional, Union
 
 from .source import Source
 from .token_kind import TokenKind
@@ -230,13 +230,13 @@ def __deepcopy__(self, memo):
             **{key: deepcopy(getattr(self, key), memo) for key in self.keys}
         )
 
-    def __init_subclass__(cls, **kwargs):
-        super().__init_subclass__(**kwargs)
+    def __init_subclass__(cls):
+        super().__init_subclass__()
         name = cls.__name__
         if name.endswith("Node"):
             name = name[:-4]
         cls.kind = camel_to_snake(name)
-        keys = []
+        keys: List[str] = []
         for base in cls.__bases__:
             # noinspection PyUnresolvedReferences
             keys.extend(base.keys)

src/graphql/language/visitor.py

@@ -151,9 +151,9 @@ def enter(self, node, key, parent, path, ancestors):
     # Provide special return values as attributes
     BREAK, SKIP, REMOVE, IDLE = BREAK, SKIP, REMOVE, IDLE
 
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls):
         """Verify that all defined handlers are valid."""
-        super().__init_subclass__(**kwargs)
+        super().__init_subclass__()
         for attr, val in cls.__dict__.items():
             if attr.startswith("_"):
                 continue

src/graphql/pyutils/frozen_dict.py

@@ -18,9 +18,6 @@ def __delitem__(self, key):
     def __setitem__(self, key, value):
         raise FrozenError
 
-    def __add__(self, value):
-        return dict.__add__(self, value)
-
     def __iadd__(self, value):
         raise FrozenError
 

src/graphql/type/directives.py

@@ -108,7 +108,7 @@ def __repr__(self):
     def __eq__(self, other):
         return self is other or (
             isinstance(other, GraphQLDirective)
-            and self.type == other.type
+            and self.name == other.name
             and self.locations == other.locations
             and self.args == other.args
             and self.is_repeatable == other.is_repeatable

src/graphql/type/validate.py

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

tests/error/test_format_error.py

@@ -1,3 +1,5 @@
+from typing import List, Union
+
 from pytest import raises  # type: ignore
 
 from graphql.error import GraphQLError, format_error
@@ -8,7 +10,7 @@ def describe_format_error():
     def throw_if_not_an_error():
         with raises(TypeError):
             # noinspection PyTypeChecker
-            format_error(None)
+            format_error(None)  # type: ignore
 
     def format_graphql_error():
         source = Source(
@@ -17,7 +19,7 @@ def format_graphql_error():
               something
             }"""
         )
-        path = ["one", 2]
+        path: List[Union[int, str]] = ["one", 2]
         extensions = {"ext": None}
         error = GraphQLError(
             "test message",
@@ -37,5 +39,5 @@ def format_graphql_error():
 
     def add_default_message():
         # noinspection PyTypeChecker
-        error = format_error(GraphQLError(None))
+        error = format_error(GraphQLError(None))  # type: ignore
         assert error["message"] == "An unknown error occurred."

tests/error/test_graphql_error.py

@@ -1,4 +1,4 @@
-from typing import cast
+from typing import cast, List, Union
 
 from graphql.error import GraphQLError, format_error, print_error
 from graphql.language import (
@@ -109,13 +109,13 @@ def serializes_to_include_message_and_locations():
         )
 
     def serializes_to_include_path():
-        path = ["path", 3, "to", "field"]
+        path: List[Union[int, str]] = ["path", 3, "to", "field"]
         e = GraphQLError("msg", path=path)
         assert e.path is path
         assert repr(e) == "GraphQLError('msg', path=['path', 3, 'to', 'field'])"
 
     def default_error_formatter_includes_path():
-        path = ["path", 3, "to", "field"]
+        path: List[Union[int, str]] = ["path", 3, "to", "field"]
         e = GraphQLError("msg", path=path)
         formatted = format_error(e)
         assert formatted == e.formatted

tests/error/test_located_error.py

@@ -1,15 +1,17 @@
+from typing import cast, Any
+
 from graphql.error import GraphQLError, located_error
 
 
 def describe_located_error():
     def passes_graphql_error_through():
         path = ["path", 3, "to", "field"]
         # noinspection PyArgumentEqualDefault
-        e = GraphQLError("msg", None, None, None, path)
+        e = GraphQLError("msg", None, None, None, path)  # type: ignore
         assert located_error(e, [], []) == e
 
     def passes_graphql_error_ish_through():
-        e = Exception("I am an ordinary exception")
+        e = cast(GraphQLError, Exception("I am an ordinary exception"))
         e.locations = []
         e.path = []
         e.nodes = []
@@ -18,6 +20,6 @@ def passes_graphql_error_ish_through():
         assert located_error(e, [], []) == e
 
     def does_not_pass_through_elasticsearch_like_errors():
-        e = Exception("I am from elasticsearch")
+        e = cast(Any, Exception("I am from elasticsearch"))
         e.path = "/something/feed/_search"
         assert located_error(e, [], []) != e

tests/execution/test_abstract.py

@@ -249,6 +249,7 @@ def resolve_type_on_interface_yields_useful_error():
             ]
         }
 
+        assert result.errors
         assert len(result.errors) == 1
         assert format_error(result.errors[0]) == {
             "message": "Runtime Object type 'Human'"
@@ -324,6 +325,7 @@ def resolve_type_on_union_yields_useful_error():
             ]
         }
 
+        assert result.errors
         assert len(result.errors) == 1
         assert format_error(result.errors[0]) == {
             "message": "Runtime Object type 'Human'"
@@ -333,20 +335,22 @@ def resolve_type_on_union_yields_useful_error():
         }
 
     def returning_invalid_value_from_resolve_type_yields_useful_error():
-        fooInterface = GraphQLInterfaceType(
+        foo_interface = GraphQLInterfaceType(  # type: ignore
             "FooInterface",
             {"bar": GraphQLField(GraphQLString)},
             resolve_type=lambda *_args: [],
         )
 
         foo_object = GraphQLObjectType(
-            "FooObject", {"bar": GraphQLField(GraphQLString)}, interfaces=[fooInterface]
+            "FooObject",
+            {"bar": GraphQLField(GraphQLString)},
+            interfaces=[foo_interface],
         )
 
         schema = GraphQLSchema(
             GraphQLObjectType(
                 "Query",
-                {"foo": GraphQLField(fooInterface, resolve=lambda *_args: "dummy")},
+                {"foo": GraphQLField(foo_interface, resolve=lambda *_args: "dummy")},
             ),
             types=[foo_object],
         )

tests/execution/test_abstract_async.py

@@ -179,7 +179,7 @@ async def is_type_of_with_async_error():
         # Note: we get two errors, because first all types are resolved
         # and only then they are checked sequentially
         assert result.data == {"pets": [None, None]}
-        assert list(map(format_error, result.errors)) == [
+        assert list(map(format_error, result.errors)) == [  # type: ignore
             {
                 "message": "We are testing this error",
                 "locations": [(3, 15)],
@@ -329,6 +329,7 @@ async def resolve_type_on_interface_yields_useful_error():
             ]
         }
 
+        assert result.errors
         assert len(result.errors) == 1
         assert format_error(result.errors[0]) == {
             "message": "Runtime Object type 'Human'"
@@ -405,6 +406,7 @@ async def resolve_type_on_union_yields_useful_error():
             ]
         }
 
+        assert result.errors
         assert len(result.errors) == 1
         assert format_error(result.errors[0]) == {
             "message": "Runtime Object type 'Human'"

tests/execution/test_customize.py

@@ -33,7 +33,7 @@ def uses_a_custom_execution_context_class():
         class TestExecutionContext(ExecutionContext):
             def resolve_field(self, parent_type, source, field_nodes, path):
                 result = super().resolve_field(parent_type, source, field_nodes, path)
-                return result * 2
+                return result * 2  # type: ignore
 
         assert execute(schema, query, execution_context_class=TestExecutionContext) == (
             {"foo": "barbar"},

tests/execution/test_executor.py

@@ -32,7 +32,7 @@ def throws_if_no_document_is_provided():
         )
 
         with raises(TypeError) as exc_info:
-            assert execute(schema=schema, document=None)
+            assert execute(schema=schema, document=None)  # type: ignore
 
         assert str(exc_info.value) == "Must provide document"
 
@@ -41,7 +41,7 @@ def throws_if_no_schema_is_provided():
         document = parse("{ field }")
 
         with raises(TypeError) as exc_info:
-            assert execute(schema=None, document=document)
+            assert execute(schema=None, document=document)  # type: ignore
 
         assert str(exc_info.value) == "Expected None to be a GraphQL schema."
 
@@ -84,10 +84,10 @@ def pic(self, _info, size=50):
                 return f"Pic of size: {size}"
 
             def deep(self, _info):
-                return DeepData()
+                return DeepData()  # type: ignore
 
             def promise(self, _info):
-                return promise_data()
+                return promise_data()  # type: ignore
 
         # noinspection PyMethodMayBeStatic,PyMethodMayBeStatic
         class DeepData:
@@ -266,7 +266,7 @@ def resolve(_obj, info):
             field_name="test",
             field_nodes=[field],
             return_type=GraphQLString,
-            parent_type=schema.query_type,
+            parent_type=cast(GraphQLObjectType, schema.query_type),
             path=ResponsePath(None, "result"),
             schema=schema,
             fragments={},