More modernization of typing annotations in src

Author: Cito

src/graphql/error/graphql_error.py

@@ -1,7 +1,9 @@
 """GraphQL Error"""
 
+from __future__ import annotations
+
 from sys import exc_info
-from typing import TYPE_CHECKING, Any, Collection, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Collection, Dict
 
 try:
     from typing import TypedDict
@@ -39,12 +41,12 @@ class GraphQLFormattedError(TypedDict, total=False):
     message: str
     # If an error can be associated to a particular point in the requested
     # GraphQL document, it should contain a list of locations.
-    locations: List["FormattedSourceLocation"]
+    locations: list[FormattedSourceLocation]
     # If an error can be associated to a particular field in the GraphQL result,
     # it _must_ contain an entry with the key `path` that details the path of
     # the response field which experienced the error. This allows clients to
     # identify whether a null result is intentional or caused by a runtime error.
-    path: List[Union[str, int]]
+    path: list[str | int]
     # Reserved for implementors to extend the protocol however they see fit,
     # and hence there are no additional restrictions on its contents.
     extensions: GraphQLErrorExtensions
@@ -62,7 +64,7 @@ class GraphQLError(Exception):
     message: str
     """A message describing the Error for debugging purposes"""
 
-    locations: Optional[List["SourceLocation"]]
+    locations: list[SourceLocation] | None
     """Source locations
 
     A list of (line, column) locations within the source GraphQL document which
@@ -73,7 +75,7 @@ class GraphQLError(Exception):
     the field which produced the error.
     """
 
-    path: Optional[List[Union[str, int]]]
+    path: list[str | int] | None
     """
 
     A list of field names and array indexes describing the JSON-path into the execution
@@ -82,27 +84,27 @@ class GraphQLError(Exception):
     Only included for errors during execution.
     """
 
-    nodes: Optional[List["Node"]]
+    nodes: list[Node] | None
     """A list of GraphQL AST Nodes corresponding to this error"""
 
-    source: Optional["Source"]
+    source: Source | None
     """The source GraphQL document for the first location of this error
 
     Note that if this Error represents more than one node, the source may not represent
     nodes after the first node.
     """
 
-    positions: Optional[Collection[int]]
+    positions: Collection[int] | None
     """Error positions
 
     A list of character offsets within the source GraphQL document which correspond
     to this error.
     """
 
-    original_error: Optional[Exception]
+    original_error: Exception | None
     """The original error thrown from a field resolver during execution"""
 
-    extensions: Optional[GraphQLErrorExtensions]
+    extensions: GraphQLErrorExtensions | None
     """Extension fields to add to the formatted error"""
 
     __slots__ = (
@@ -121,12 +123,12 @@ class GraphQLError(Exception):
     def __init__(
         self,
         message: str,
-        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[GraphQLErrorExtensions] = None,
+        nodes: Collection[Node] | Node | None = None,
+        source: Source | None = None,
+        positions: Collection[int] | None = None,
+        path: Collection[str | int] | None = None,
+        original_error: Exception | None = None,
+        extensions: GraphQLErrorExtensions | None = None,
     ) -> None:
         """Initialize a GraphQLError."""
         super().__init__(message)
@@ -155,7 +157,7 @@ def __init__(
             positions = [loc.start for loc in node_locations]
         self.positions = positions or None
         if positions and source:
-            locations: Optional[List[SourceLocation]] = [
+            locations: list[SourceLocation] | None = [
                 source.get_location(pos) for pos in positions
             ]
         else:

src/graphql/error/located_error.py

@@ -1,7 +1,9 @@
 """Located GraphQL Error"""
 
+from __future__ import annotations
+
 from contextlib import suppress
-from typing import TYPE_CHECKING, Collection, Optional, Union
+from typing import TYPE_CHECKING, Collection
 
 from ..pyutils import inspect
 from .graphql_error import GraphQLError
@@ -14,8 +16,8 @@
 
 def located_error(
     original_error: Exception,
-    nodes: Optional[Union[None, Collection["Node"]]] = None,
-    path: Optional[Collection[Union[str, int]]] = None,
+    nodes: None | Collection[Node] = None,
+    path: Collection[str | int] | None = None,
 ) -> GraphQLError:
     """Located GraphQL Error
 

src/graphql/error/syntax_error.py

@@ -1,6 +1,6 @@
 """GraphQL Syntax Error"""
 
-from __future__ import annotations  # Python < 3.10
+from __future__ import annotations
 
 from typing import TYPE_CHECKING
 

src/graphql/execution/async_iterables.py

@@ -1,6 +1,6 @@
 """Helpers for async iterables"""
 
-from __future__ import annotations  # Python < 3.10
+from __future__ import annotations
 
 from contextlib import AbstractAsyncContextManager
 from typing import (

src/graphql/execution/collect_fields.py

@@ -1,7 +1,9 @@
 """Collect fields"""
 
+from __future__ import annotations
+
 from collections import defaultdict
-from typing import Any, Dict, List, NamedTuple, Optional, Set, Union
+from typing import Any, NamedTuple
 
 from ..language import (
     FieldNode,
@@ -29,21 +31,21 @@
 class PatchFields(NamedTuple):
     """Optionally labelled set of fields to be used as a patch."""
 
-    label: Optional[str]
-    fields: Dict[str, List[FieldNode]]
+    label: str | None
+    fields: dict[str, list[FieldNode]]
 
 
 class FieldsAndPatches(NamedTuple):
     """Tuple of collected fields and patches to be applied."""
 
-    fields: Dict[str, List[FieldNode]]
-    patches: List[PatchFields]
+    fields: dict[str, list[FieldNode]]
+    patches: list[PatchFields]
 
 
 def collect_fields(
     schema: GraphQLSchema,
-    fragments: Dict[str, FragmentDefinitionNode],
-    variable_values: Dict[str, Any],
+    fragments: dict[str, FragmentDefinitionNode],
+    variable_values: dict[str, Any],
     runtime_type: GraphQLObjectType,
     operation: OperationDefinitionNode,
 ) -> FieldsAndPatches:
@@ -57,8 +59,8 @@ def collect_fields(
 
     For internal use only.
     """
-    fields: Dict[str, List[FieldNode]] = defaultdict(list)
-    patches: List[PatchFields] = []
+    fields: dict[str, list[FieldNode]] = defaultdict(list)
+    patches: list[PatchFields] = []
     collect_fields_impl(
         schema,
         fragments,
@@ -75,11 +77,11 @@ def collect_fields(
 
 def collect_subfields(
     schema: GraphQLSchema,
-    fragments: Dict[str, FragmentDefinitionNode],
-    variable_values: Dict[str, Any],
+    fragments: dict[str, FragmentDefinitionNode],
+    variable_values: dict[str, Any],
     operation: OperationDefinitionNode,
     return_type: GraphQLObjectType,
-    field_nodes: List[FieldNode],
+    field_nodes: list[FieldNode],
 ) -> FieldsAndPatches:
     """Collect subfields.
 
@@ -92,10 +94,10 @@ def collect_subfields(
 
     For internal use only.
     """
-    sub_field_nodes: Dict[str, List[FieldNode]] = defaultdict(list)
-    visited_fragment_names: Set[str] = set()
+    sub_field_nodes: dict[str, list[FieldNode]] = defaultdict(list)
+    visited_fragment_names: set[str] = set()
 
-    sub_patches: List[PatchFields] = []
+    sub_patches: list[PatchFields] = []
     sub_fields_and_patches = FieldsAndPatches(sub_field_nodes, sub_patches)
 
     for node in field_nodes:
@@ -116,17 +118,17 @@ def collect_subfields(
 
 def collect_fields_impl(
     schema: GraphQLSchema,
-    fragments: Dict[str, FragmentDefinitionNode],
-    variable_values: Dict[str, Any],
+    fragments: dict[str, FragmentDefinitionNode],
+    variable_values: dict[str, Any],
     operation: OperationDefinitionNode,
     runtime_type: GraphQLObjectType,
     selection_set: SelectionSetNode,
-    fields: Dict[str, List[FieldNode]],
-    patches: List[PatchFields],
-    visited_fragment_names: Set[str],
+    fields: dict[str, list[FieldNode]],
+    patches: list[PatchFields],
+    visited_fragment_names: set[str],
 ) -> None:
     """Collect fields (internal implementation)."""
-    patch_fields: Dict[str, List[FieldNode]]
+    patch_fields: dict[str, list[FieldNode]]
 
     for selection in selection_set.selections:
         if isinstance(selection, FieldNode):
@@ -216,14 +218,14 @@ def collect_fields_impl(
 class DeferValues(NamedTuple):
     """Values of an active defer directive."""
 
-    label: Optional[str]
+    label: str | None
 
 
 def get_defer_values(
     operation: OperationDefinitionNode,
-    variable_values: Dict[str, Any],
-    node: Union[FragmentSpreadNode, InlineFragmentNode],
-) -> Optional[DeferValues]:
+    variable_values: dict[str, Any],
+    node: FragmentSpreadNode | InlineFragmentNode,
+) -> DeferValues | None:
     """Get values of defer directive if active.
 
     Returns an object containing the `@defer` arguments if a field should be
@@ -246,8 +248,8 @@ def get_defer_values(
 
 
 def should_include_node(
-    variable_values: Dict[str, Any],
-    node: Union[FragmentSpreadNode, FieldNode, InlineFragmentNode],
+    variable_values: dict[str, Any],
+    node: FragmentSpreadNode | FieldNode | InlineFragmentNode,
 ) -> bool:
     """Check if node should be included
 
@@ -267,7 +269,7 @@ def should_include_node(
 
 def does_fragment_condition_match(
     schema: GraphQLSchema,
-    fragment: Union[FragmentDefinitionNode, InlineFragmentNode],
+    fragment: FragmentDefinitionNode | InlineFragmentNode,
     type_: GraphQLObjectType,
 ) -> bool:
     """Determine if a fragment is applicable to the given type."""

src/graphql/execution/execute.py

@@ -1,6 +1,6 @@
 """GraphQL execution"""
 
-from __future__ import annotations  # Python < 3.10
+from __future__ import annotations
 
 from asyncio import Event, as_completed, ensure_future, gather, shield, sleep, wait_for
 from collections.abc import Mapping

src/graphql/execution/middleware.py

@@ -1,8 +1,10 @@
 """Middleware manager"""
 
+from __future__ import annotations
+
 from functools import partial, reduce
 from inspect import isfunction
-from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple
+from typing import Any, Callable, Iterator
 
 try:
     from typing import TypeAlias
@@ -30,8 +32,8 @@ class MiddlewareManager:
     # allow custom attributes (not used internally)
     __slots__ = "__dict__", "middlewares", "_middleware_resolvers", "_cached_resolvers"
 
-    _cached_resolvers: Dict[GraphQLFieldResolver, GraphQLFieldResolver]
-    _middleware_resolvers: Optional[List[Callable]]
+    _cached_resolvers: dict[GraphQLFieldResolver, GraphQLFieldResolver]
+    _middleware_resolvers: list[Callable] | None
 
     def __init__(self, *middlewares: Any) -> None:
         self.middlewares = middlewares
@@ -59,7 +61,7 @@ def get_field_resolver(
         return self._cached_resolvers[field_resolver]
 
 
-def get_middleware_resolvers(middlewares: Tuple[Any, ...]) -> Iterator[Callable]:
+def get_middleware_resolvers(middlewares: tuple[Any, ...]) -> Iterator[Callable]:
     """Get a list of resolver functions from a list of classes or functions."""
     for middleware in middlewares:
         if isfunction(middleware):