make optional types explicit throughout the rest of the codebase

Signed-off-by: Oleg Höfling <[email protected]>

Author: hoefling

mypy.ini

@@ -1,7 +1,7 @@
 [mypy]
 python_version = 3.8
 check_untyped_defs = True
-no_implicit_optional = False
+no_implicit_optional = True
 strict_optional = True
 warn_redundant_casts = True
 warn_unused_ignores = True

src/graphql/error/graphql_error.py

@@ -85,12 +85,12 @@ class GraphQLError(Exception):
     def __init__(
         self,
         message: str,
-        nodes: Union[Collection["Node"], "Node"] = None,
-        source: "Source" = None,
-        positions: Collection[int] = None,
-        path: Collection[Union[str, int]] = None,
-        original_error: Exception = None,
-        extensions: Dict[str, Any] = None,
+        nodes: Union[Collection["Node"], "Node", None] = None,
+        source: Optional["Source"] = None,
+        positions: Optional[Collection[int]] = None,
+        path: Optional[Collection[Union[str, int]]] = None,
+        original_error: Optional[Exception] = None,
+        extensions: Optional[Dict[str, Any]] = None,
     ) -> None:
         super().__init__(message)
         self.message = message

src/graphql/execution/execute.py

@@ -117,12 +117,12 @@ def execute(
     document: DocumentNode,
     root_value: Any = None,
     context_value: Any = None,
-    variable_values: Dict[str, Any] = None,
-    operation_name: str = None,
-    field_resolver: GraphQLFieldResolver = None,
-    type_resolver: GraphQLTypeResolver = None,
-    middleware: Middleware = None,
-    execution_context_class: Type["ExecutionContext"] = None,
+    variable_values: Optional[Dict[str, Any]] = None,
+    operation_name: Optional[str] = None,
+    field_resolver: Optional[GraphQLFieldResolver] = None,
+    type_resolver: Optional[GraphQLTypeResolver] = None,
+    middleware: Optional[Middleware] = None,
+    execution_context_class: Optional[Type["ExecutionContext"]] = None,
 ) -> AwaitableOrValue[ExecutionResult]:
     """Execute a GraphQL operation.
 
@@ -222,11 +222,11 @@ def build(
         document: DocumentNode,
         root_value: Any = None,
         context_value: Any = None,
-        raw_variable_values: Dict[str, Any] = None,
-        operation_name: str = None,
-        field_resolver: GraphQLFieldResolver = None,
-        type_resolver: GraphQLTypeResolver = None,
-        middleware: Middleware = None,
+        raw_variable_values: Optional[Dict[str, Any]] = None,
+        operation_name: Optional[str] = None,
+        field_resolver: Optional[GraphQLFieldResolver] = None,
+        type_resolver: Optional[GraphQLTypeResolver] = None,
+        middleware: Optional[Middleware] = None,
     ) -> Union[List[GraphQLError], "ExecutionContext"]:
         """Build an execution context
 
@@ -1030,7 +1030,7 @@ def collect_subfields(
 def assert_valid_execution_arguments(
     schema: GraphQLSchema,
     document: DocumentNode,
-    raw_variable_values: Dict[str, Any] = None,
+    raw_variable_values: Optional[Dict[str, Any]] = None,
 ) -> None:
     """Check that the arguments are acceptable.
 

src/graphql/execution/values.py

@@ -37,7 +37,7 @@ def get_variable_values(
     schema: GraphQLSchema,
     var_def_nodes: FrozenList[VariableDefinitionNode],
     inputs: Dict[str, Any],
-    max_errors: int = None,
+    max_errors: Optional[int] = None,
 ) -> CoercedVariableValues:
     """Get coerced variable values based on provided definitions.
 
@@ -144,7 +144,7 @@ def on_input_value_error(
 def get_argument_values(
     type_def: Union[GraphQLField, GraphQLDirective],
     node: Union[FieldNode, DirectiveNode],
-    variable_values: Dict[str, Any] = None,
+    variable_values: Optional[Dict[str, Any]] = None,
 ) -> Dict[str, Any]:
     """Get coerced argument values based on provided definitions and nodes.
 
@@ -221,7 +221,7 @@ def get_argument_values(
 def get_directive_values(
     directive_def: GraphQLDirective,
     node: NodeWithDirective,
-    variable_values: Dict[str, Any] = None,
+    variable_values: Optional[Dict[str, Any]] = None,
 ) -> Optional[Dict[str, Any]]:
     """Get coerced argument values based on provided nodes.
 

src/graphql/language/ast.py

@@ -93,8 +93,8 @@ def __init__(
         end: int,
         line: int,
         column: int,
-        prev: "Token" = None,
-        value: str = None,
+        prev: Optional["Token"] = None,
+        value: Optional[str] = None,
     ) -> None:
         self.kind = kind
         self.start, self.end = start, end

src/graphql/language/parser.py

@@ -1025,7 +1025,7 @@ def expect_optional_keyword(self, value: str) -> bool:
 
         return False
 
-    def unexpected(self, at_token: Token = None) -> GraphQLError:
+    def unexpected(self, at_token: Optional[Token] = None) -> GraphQLError:
         """Create an error when an unexpected lexed token is encountered."""
         token = at_token or self._lexer.token
         return GraphQLSyntaxError(

src/graphql/language/source.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from .location import SourceLocation
 
 __all__ = ["Source"]
@@ -9,7 +11,10 @@ class Source:
     __slots__ = "body", "name", "location_offset"
 
     def __init__(
-        self, body: str, name: str = None, location_offset: SourceLocation = None
+        self,
+        body: str,
+        name: Optional[str] = None,
+        location_offset: Optional[SourceLocation] = None,
     ) -> None:
         """Initialize source input.
 

src/graphql/pyutils/did_you_mean.py

@@ -1,11 +1,11 @@
-from typing import Sequence
+from typing import Optional, Sequence
 
 __all__ = ["did_you_mean"]
 
 MAX_LENGTH = 5
 
 
-def did_you_mean(suggestions: Sequence[str], sub_message: str = None) -> str:
+def did_you_mean(suggestions: Sequence[str], sub_message: Optional[str] = None) -> str:
     """Given [ A, B, C ] return ' Did you mean A, B, or C?'"""
     if not suggestions:
         return ""

src/graphql/subscription/map_async_iterator.py

@@ -1,7 +1,7 @@
 from asyncio import Event, ensure_future, Future, wait
 from concurrent.futures import FIRST_COMPLETED
 from inspect import isasyncgen, isawaitable
-from typing import AsyncIterable, Callable, Set
+from typing import AsyncIterable, Callable, Optional, Set
 
 __all__ = ["MapAsyncIterator"]
 
@@ -21,7 +21,7 @@ def __init__(
         self,
         iterable: AsyncIterable,
         callback: Callable,
-        reject_callback: Callable = None,
+        reject_callback: Optional[Callable] = None,
     ) -> None:
         self.iterator = iterable.__aiter__()
         self.callback = callback

src/graphql/type/definition.py

@@ -198,10 +198,10 @@ class GraphQLNamedType(GraphQLType):
     def __init__(
         self,
         name: str,
-        description: str = None,
-        extensions: Dict[str, Any] = None,
-        ast_node: TypeDefinitionNode = None,
-        extension_ast_nodes: Collection[TypeExtensionNode] = None,
+        description: Optional[str] = None,
+        extensions: Optional[Dict[str, Any]] = None,
+        ast_node: Optional[TypeDefinitionNode] = None,
+        extension_ast_nodes: Optional[Collection[TypeExtensionNode]] = None,
     ) -> None:
         if not name:
             raise TypeError("Must provide name.")
@@ -322,13 +322,13 @@ def serialize_odd(value):
     def __init__(
         self,
         name: str,
-        serialize: GraphQLScalarSerializer = None,
-        parse_value: GraphQLScalarValueParser = None,
-        parse_literal: GraphQLScalarLiteralParser = None,
-        description: str = None,
-        extensions: Dict[str, Any] = None,
-        ast_node: ScalarTypeDefinitionNode = None,
-        extension_ast_nodes: Collection[ScalarTypeExtensionNode] = None,
+        serialize: Optional[GraphQLScalarSerializer] = None,
+        parse_value: Optional[GraphQLScalarValueParser] = None,
+        parse_literal: Optional[GraphQLScalarLiteralParser] = None,
+        description: Optional[str] = None,
+        extensions: Optional[Dict[str, Any]] = None,
+        ast_node: Optional[ScalarTypeDefinitionNode] = None,
+        extension_ast_nodes: Optional[Collection[ScalarTypeExtensionNode]] = None,
     ) -> None:
         super().__init__(
             name=name,
@@ -392,7 +392,9 @@ def parse_value(value: Any) -> Any:
         """
         return value
 
-    def parse_literal(self, node: ValueNode, _variables: Dict[str, Any] = None) -> Any:
+    def parse_literal(
+        self, node: ValueNode, _variables: Optional[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
@@ -444,13 +446,13 @@ class GraphQLField:
     def __init__(
         self,
         type_: "GraphQLOutputType",
-        args: GraphQLArgumentMap = None,
-        resolve: "GraphQLFieldResolver" = None,
-        subscribe: "GraphQLFieldResolver" = None,
-        description: str = None,
-        deprecation_reason: str = None,
-        extensions: Dict[str, Any] = None,
-        ast_node: FieldDefinitionNode = None,
+        args: Optional[GraphQLArgumentMap] = None,
+        resolve: Optional["GraphQLFieldResolver"] = None,
+        subscribe: Optional["GraphQLFieldResolver"] = None,
+        description: Optional[str] = None,
+        deprecation_reason: Optional[str] = None,
+        extensions: Optional[Dict[str, Any]] = None,
+        ast_node: Optional[FieldDefinitionNode] = None,
     ) -> None:
         if not is_output_type(type_):
             raise TypeError("Field type must be an output type.")
@@ -588,10 +590,10 @@ def __init__(
         self,
         type_: "GraphQLInputType",
         default_value: Any = Undefined,
-        description: str = None,
-        out_name: str = None,
-        extensions: Dict[str, Any] = None,
-        ast_node: InputValueDefinitionNode = None,
+        description: Optional[str] = None,
+        out_name: Optional[str] = None,
+        extensions: Optional[Dict[str, Any]] = None,
+        ast_node: Optional[InputValueDefinitionNode] = None,
     ) -> None:
         if not is_input_type(type_):
             raise TypeError(f"Argument type must be a GraphQL input type.")
@@ -682,12 +684,12 @@ def __init__(
         self,
         name: str,
         fields: Thunk[GraphQLFieldMap],
-        interfaces: Thunk[Collection["GraphQLInterfaceType"]] = None,
-        is_type_of: GraphQLIsTypeOfFn = None,
-        extensions: Dict[str, Any] = None,
-        description: str = None,
-        ast_node: ObjectTypeDefinitionNode = None,
-        extension_ast_nodes: Collection[ObjectTypeExtensionNode] = None,
+        interfaces: Optional[Thunk[Collection["GraphQLInterfaceType"]]] = None,
+        is_type_of: Optional[GraphQLIsTypeOfFn] = None,
+        extensions: Optional[Dict[str, Any]] = None,
+        description: Optional[str] = None,
+        ast_node: Optional[ObjectTypeDefinitionNode] = None,
+        extension_ast_nodes: Optional[Collection[ObjectTypeExtensionNode]] = None,
     ) -> None:
         super().__init__(
             name=name,
@@ -801,13 +803,13 @@ class GraphQLInterfaceType(GraphQLNamedType):
     def __init__(
         self,
         name: str,
-        fields: Thunk[GraphQLFieldMap] = None,
-        interfaces: Thunk[Collection["GraphQLInterfaceType"]] = None,
-        resolve_type: GraphQLTypeResolver = None,
-        description: str = None,
-        extensions: Dict[str, Any] = None,
-        ast_node: InterfaceTypeDefinitionNode = None,
-        extension_ast_nodes: Collection[InterfaceTypeExtensionNode] = None,
+        fields: Optional[Thunk[GraphQLFieldMap]] = None,
+        interfaces: Optional[Thunk[Collection["GraphQLInterfaceType"]]] = None,
+        resolve_type: Optional[GraphQLTypeResolver] = None,
+        description: Optional[str] = None,
+        extensions: Optional[Dict[str, Any]] = None,
+        ast_node: Optional[InterfaceTypeDefinitionNode] = None,
+        extension_ast_nodes: Optional[Collection[InterfaceTypeExtensionNode]] = None,
     ) -> None:
         super().__init__(
             name=name,
@@ -927,11 +929,11 @@ def __init__(
         self,
         name,
         types: Thunk[Collection[GraphQLObjectType]],
-        resolve_type: GraphQLTypeResolver = None,
-        description: str = None,
-        extensions: Dict[str, Any] = None,
-        ast_node: UnionTypeDefinitionNode = None,
-        extension_ast_nodes: Collection[UnionTypeExtensionNode] = None,
+        resolve_type: Optional[GraphQLTypeResolver] = None,
+        description: Optional[str] = None,
+        extensions: Optional[Dict[str, Any]] = None,
+        ast_node: Optional[UnionTypeDefinitionNode] = None,
+        extension_ast_nodes: Optional[Collection[UnionTypeExtensionNode]] = None,
     ) -> None:
         super().__init__(
             name=name,
@@ -1033,10 +1035,10 @@ def __init__(
         self,
         name: str,
         values: Union[GraphQLEnumValueMap, Dict[str, Any], Type[Enum]],
-        description: str = None,
-        extensions: Dict[str, Any] = None,
-        ast_node: EnumTypeDefinitionNode = None,
-        extension_ast_nodes: Collection[EnumTypeExtensionNode] = None,
+        description: Optional[str] = None,
+        extensions: Optional[Dict[str, Any]] = None,
+        ast_node: Optional[EnumTypeDefinitionNode] = None,
+        extension_ast_nodes: Optional[Collection[EnumTypeExtensionNode]] = None,
     ) -> None:
         super().__init__(
             name=name,
@@ -1119,7 +1121,7 @@ def parse_value(self, value: str) -> Any:
         return Undefined
 
     def parse_literal(
-        self, value_node: ValueNode, _variables: Dict[str, Any] = None
+        self, value_node: ValueNode, _variables: Optional[Dict[str, Any]] = None
     ) -> Any:
         # Note: variables will be resolved before calling this method.
         if isinstance(value_node, EnumValueNode):
@@ -1155,10 +1157,10 @@ class GraphQLEnumValue:
     def __init__(
         self,
         value: Any = None,
-        description: str = None,
-        deprecation_reason: str = None,
-        extensions: Dict[str, Any] = None,
-        ast_node: EnumValueDefinitionNode = None,
+        description: Optional[str] = None,
+        deprecation_reason: Optional[str] = None,
+        extensions: Optional[Dict[str, Any]] = None,
+        ast_node: Optional[EnumValueDefinitionNode] = None,
     ) -> None:
         if description is not None and not is_description(description):
             raise TypeError("The description of the enum value must be a string.")
@@ -1240,11 +1242,11 @@ def __init__(
         self,
         name: str,
         fields: Thunk[GraphQLInputFieldMap],
-        description: str = None,
-        out_type: GraphQLInputFieldOutType = None,
-        extensions: Dict[str, Any] = None,
-        ast_node: InputObjectTypeDefinitionNode = None,
-        extension_ast_nodes: Collection[InputObjectTypeExtensionNode] = None,
+        description: Optional[str] = None,
+        out_type: Optional[GraphQLInputFieldOutType] = None,
+        extensions: Optional[Dict[str, Any]] = None,
+        ast_node: Optional[InputObjectTypeDefinitionNode] = None,
+        extension_ast_nodes: Optional[Collection[InputObjectTypeExtensionNode]] = None,
     ) -> None:
         super().__init__(
             name=name,
@@ -1342,10 +1344,10 @@ def __init__(
         self,
         type_: "GraphQLInputType",
         default_value: Any = Undefined,
-        description: str = None,
-        out_name: str = None,
-        extensions: Dict[str, Any] = None,
-        ast_node: InputValueDefinitionNode = None,
+        description: Optional[str] = None,
+        out_name: Optional[str] = None,
+        extensions: Optional[Dict[str, Any]] = None,
+        ast_node: Optional[InputValueDefinitionNode] = None,
     ) -> None:
         if not is_input_type(type_):
             raise TypeError(f"Input field type must be a GraphQL input type.")

src/graphql/type/directives.py

@@ -38,11 +38,11 @@ def __init__(
         self,
         name: str,
         locations: Collection[DirectiveLocation],
-        args: Dict[str, GraphQLArgument] = None,
+        args: Optional[Dict[str, GraphQLArgument]] = None,
         is_repeatable: bool = False,
-        description: str = None,
-        extensions: Dict[str, Any] = None,
-        ast_node: ast.DirectiveDefinitionNode = None,
+        description: Optional[str] = None,
+        extensions: Optional[Dict[str, Any]] = None,
+        ast_node: Optional[ast.DirectiveDefinitionNode] = None,
     ) -> None:
         if not name:
             raise TypeError("Directive must be named.")