Fix ruff issues

Author: Cito

src/graphql/execution/collect_fields.py

@@ -394,7 +394,7 @@ def build_grouped_field_sets(
         # All TargetSets that causes new grouped field sets consist only of DeferUsages
         # and have should_initiate_defer defined
 
-        new_grouped_field_set_details[cast(DeferUsageSet, masking_targets)] = (
+        new_grouped_field_set_details[cast("DeferUsageSet", masking_targets)] = (
             GroupedFieldSetDetails(new_grouped_field_set, should_initiate_defer)
         )
 

src/graphql/execution/execute.py

@@ -975,7 +975,7 @@ def complete_list_value(
 
         if stream_record is not None:
             self.incremental_publisher.set_is_final_record(
-                cast(StreamItemsRecord, current_parents)
+                cast("StreamItemsRecord", current_parents)
             )
 
         if not awaitable_indices:
@@ -1113,7 +1113,7 @@ def complete_abstract_value(
         runtime_type = resolve_type_fn(result, info, return_type)
 
         if self.is_awaitable(runtime_type):
-            runtime_type = cast(Awaitable, runtime_type)
+            runtime_type = cast("Awaitable", runtime_type)
 
             async def await_complete_object_value() -> Any:
                 value = self.complete_object_value(
@@ -1136,7 +1136,7 @@ async def await_complete_object_value() -> Any:
                 return value  # pragma: no cover
 
             return await_complete_object_value()
-        runtime_type = cast(Optional[str], runtime_type)
+        runtime_type = cast("Optional[str]", runtime_type)
 
         return self.complete_object_value(
             self.ensure_valid_runtime_type(
@@ -1358,9 +1358,9 @@ async def callback(payload: Any) -> ExecutionResult:
             # typecast to ExecutionResult, not possible to return
             # ExperimentalIncrementalExecutionResults when operation is 'subscription'.
             return (
-                await cast(Awaitable[ExecutionResult], result)
+                await cast("Awaitable[ExecutionResult]", result)
                 if self.is_awaitable(result)
-                else cast(ExecutionResult, result)
+                else cast("ExecutionResult", result)
             )
 
         return map_async_iterable(result_or_stream, callback)
@@ -1424,7 +1424,7 @@ def execute_deferred_grouped_field_set(
             )
 
             if self.is_awaitable(incremental_result):
-                incremental_result = cast(Awaitable, incremental_result)
+                incremental_result = cast("Awaitable", incremental_result)
 
                 async def await_incremental_result() -> None:
                     try:
@@ -1897,11 +1897,11 @@ def execute_sync(
         result, ExperimentalIncrementalExecutionResults
     ):
         if default_is_awaitable(result):
-            ensure_future(cast(Awaitable[ExecutionResult], result)).cancel()
+            ensure_future(cast("Awaitable[ExecutionResult]", result)).cancel()
         msg = "GraphQL execution failed to complete synchronously."
         raise RuntimeError(msg)
 
-    return cast(ExecutionResult, result)
+    return cast("ExecutionResult", result)
 
 
 def invalid_return_type_error(
@@ -1956,7 +1956,9 @@ def add_new_deferred_fragments(
         #  - the InitialResultRecord, or
         #  - a StreamItemsRecord, as `@defer` may be nested under `@stream`.
         parent = (
-            cast(Union[InitialResultRecord, StreamItemsRecord], incremental_data_record)
+            cast(
+                "Union[InitialResultRecord, StreamItemsRecord]", incremental_data_record
+            )
             if parent_defer_usage is None
             else deferred_fragment_record_from_defer_usage(
                 parent_defer_usage, new_defer_map
@@ -2069,7 +2071,7 @@ def default_type_resolver(
             is_type_of_result = type_.is_type_of(value, info)
 
             if is_awaitable(is_type_of_result):
-                append_awaitable_results(cast(Awaitable, is_type_of_result))
+                append_awaitable_results(cast("Awaitable", is_type_of_result))
                 append_awaitable_types(type_)
             elif is_type_of_result:
                 return type_.name
@@ -2257,7 +2259,7 @@ def create_source_event_stream_impl(
         return ExecutionResult(None, errors=[error])
 
     if context.is_awaitable(event_stream):
-        awaitable_event_stream = cast(Awaitable, event_stream)
+        awaitable_event_stream = cast("Awaitable", event_stream)
 
         # noinspection PyShadowingNames
         async def await_event_stream() -> AsyncIterable[Any] | ExecutionResult:

src/graphql/graphql.py

@@ -96,9 +96,9 @@ async def graphql(
     )
 
     if default_is_awaitable(result):
-        return await cast(Awaitable[ExecutionResult], result)
+        return await cast("Awaitable[ExecutionResult]", result)
 
-    return cast(ExecutionResult, result)
+    return cast("ExecutionResult", result)
 
 
 def assume_not_awaitable(_value: Any) -> bool:
@@ -149,11 +149,11 @@ def graphql_sync(
 
     # Assert that the execution was synchronous.
     if default_is_awaitable(result):
-        ensure_future(cast(Awaitable[ExecutionResult], result)).cancel()
+        ensure_future(cast("Awaitable[ExecutionResult]", result)).cancel()
         msg = "GraphQL execution failed to complete synchronously."
         raise RuntimeError(msg)
 
-    return cast(ExecutionResult, result)
+    return cast("ExecutionResult", result)
 
 
 def graphql_impl(

src/graphql/language/parser.py

@@ -255,7 +255,7 @@ def __init__(
         experimental_client_controlled_nullability: bool = False,
     ) -> None:
         if not is_source(source):
-            source = Source(cast(str, source))
+            source = Source(cast("str", source))
 
         self._no_location = no_location
         self._max_tokens = max_tokens
@@ -319,7 +319,7 @@ def parse_definition(self) -> DefinitionNode:
         )
 
         if keyword_token.kind is TokenKind.NAME:
-            token_name = cast(str, keyword_token.value)
+            token_name = cast("str", keyword_token.value)
             method_name = self._parse_type_system_definition_method_names.get(
                 token_name
             )
@@ -472,7 +472,9 @@ def parse_arguments(self, is_const: bool) -> list[ArgumentNode]:
         """Arguments[Const]: (Argument[?Const]+)"""
         item = self.parse_const_argument if is_const else self.parse_argument
         return self.optional_many(
-            TokenKind.PAREN_L, cast(Callable[[], ArgumentNode], item), TokenKind.PAREN_R
+            TokenKind.PAREN_L,
+            cast("Callable[[], ArgumentNode]", item),
+            TokenKind.PAREN_R,
         )
 
     def parse_argument(self, is_const: bool = False) -> ArgumentNode:
@@ -487,7 +489,7 @@ def parse_argument(self, is_const: bool = False) -> ArgumentNode:
 
     def parse_const_argument(self) -> ConstArgumentNode:
         """Argument[Const]: Name : Value[Const]"""
-        return cast(ConstArgumentNode, self.parse_argument(True))
+        return cast("ConstArgumentNode", self.parse_argument(True))
 
     # Implement the parsing rules in the Fragments section.
 
@@ -641,7 +643,7 @@ def parse_variable_value(self, is_const: bool) -> VariableNode:
         return self.parse_variable()
 
     def parse_const_value_literal(self) -> ConstValueNode:
-        return cast(ConstValueNode, self.parse_value_literal(True))
+        return cast("ConstValueNode", self.parse_value_literal(True))
 
     # Implement the parsing rules in the Directives section.
 
@@ -654,7 +656,7 @@ def parse_directives(self, is_const: bool) -> list[DirectiveNode]:
         return directives
 
     def parse_const_directives(self) -> list[ConstDirectiveNode]:
-        return cast(List[ConstDirectiveNode], self.parse_directives(True))
+        return cast("List[ConstDirectiveNode]", self.parse_directives(True))
 
     def parse_directive(self, is_const: bool) -> DirectiveNode:
         """Directive[Const]: @ Name Arguments[?Const]?"""
@@ -704,7 +706,7 @@ def parse_type_system_extension(self) -> TypeSystemExtensionNode:
         keyword_token = self._lexer.lookahead()
         if keyword_token.kind == TokenKind.NAME:
             method_name = self._parse_type_extension_method_names.get(
-                cast(str, keyword_token.value)
+                cast("str", keyword_token.value)
             )
             if method_name:  # pragma: no cover
                 return getattr(self, f"parse_{method_name}")()

src/graphql/language/print_location.py

@@ -73,7 +73,7 @@ def print_source_location(source: Source, source_location: SourceLocation) -> st
 def print_prefixed_lines(*lines: tuple[str, str | None]) -> str:
     """Print lines specified like this: ("prefix", "string")"""
     existing_lines = [
-        cast(Tuple[str, str], line) for line in lines if line[1] is not None
+        cast("Tuple[str, str]", line) for line in lines if line[1] is not None
     ]
     pad_len = max(len(line[0]) for line in existing_lines)
     return "\n".join(

src/graphql/pyutils/async_reduce.py

@@ -41,7 +41,7 @@ async def async_callback(
                 )
                 return await result if is_awaitable(result) else result  # type: ignore
 
-            accumulator = async_callback(cast(Awaitable[U], accumulator), value)
+            accumulator = async_callback(cast("Awaitable[U]", accumulator), value)
         else:
-            accumulator = callback(cast(U, accumulator), value)
+            accumulator = callback(cast("U", accumulator), value)
     return accumulator

src/graphql/pyutils/identity_func.py

@@ -11,7 +11,7 @@
 
 T = TypeVar("T")
 
-DEFAULT_VALUE = cast(Any, Undefined)
+DEFAULT_VALUE = cast("Any", Undefined)
 
 
 def identity_func(x: T = DEFAULT_VALUE, *_args: Any) -> T:

src/graphql/pyutils/merge_kwargs.py

@@ -9,4 +9,4 @@
 
 def merge_kwargs(base_dict: T, **kwargs: Any) -> T:
     """Return arbitrary typed dictionary with some keyword args merged in."""
-    return cast(T, {**cast(Dict, base_dict), **kwargs})
+    return cast("T", {**cast("Dict", base_dict), **kwargs})

src/graphql/type/definition.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from enum import Enum
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -19,6 +18,18 @@
     overload,
 )
 
+try:
+    from typing import TypedDict
+except ImportError:  # Python < 3.8
+    from typing_extensions import TypedDict
+try:
+    from typing import TypeAlias, TypeGuard
+except ImportError:  # Python < 3.10
+    from typing_extensions import TypeAlias, TypeGuard
+
+if TYPE_CHECKING:
+    from enum import Enum
+
 from ..error import GraphQLError
 from ..language import (
     EnumTypeDefinitionNode,
@@ -57,18 +68,10 @@
 from ..utilities.value_from_ast_untyped import value_from_ast_untyped
 from .assert_name import assert_enum_value_name, assert_name
 
-try:
-    from typing import TypedDict
-except ImportError:  # Python < 3.8
-    from typing_extensions import TypedDict
-try:
-    from typing import TypeAlias, TypeGuard
-except ImportError:  # Python < 3.10
-    from typing_extensions import TypeAlias, TypeGuard
-
 if TYPE_CHECKING:
     from .schema import GraphQLSchema
 
+
 __all__ = [
     "GraphQLAbstractType",
     "GraphQLArgument",
@@ -503,7 +506,7 @@ def __init__(
             args = {
                 assert_name(name): value
                 if isinstance(value, GraphQLArgument)
-                else GraphQLArgument(cast(GraphQLInputType, value))
+                else GraphQLArgument(cast("GraphQLInputType", value))
                 for name, value in args.items()
             }
         else:
@@ -1077,7 +1080,7 @@ def __init__(
             extension_ast_nodes=extension_ast_nodes,
         )
         try:  # check for enum
-            values = cast(Enum, values).__members__  # type: ignore
+            values = cast("Enum", values).__members__  # type: ignore
         except AttributeError:
             if not isinstance(values, Mapping) or not all(
                 isinstance(name, str) for name in values
@@ -1090,9 +1093,9 @@ def __init__(
                         " with value names as keys."
                     )
                     raise TypeError(msg) from error
-            values = cast(Dict[str, Any], values)
+            values = cast("Dict[str, Any]", values)
         else:
-            values = cast(Dict[str, Enum], values)
+            values = cast("Dict[str, Enum]", values)
             if names_as_values is False:
                 values = {key: value.value for key, value in values.items()}
             elif names_as_values is True:
@@ -1662,7 +1665,7 @@ def get_nullable_type(
     """Unwrap possible non-null type"""
     if is_non_null_type(type_):
         type_ = type_.of_type
-    return cast(Optional[GraphQLNullableType], type_)
+    return cast("Optional[GraphQLNullableType]", type_)
 
 
 # These named types do not include modifiers like List or NonNull.
@@ -1707,7 +1710,7 @@ def get_named_type(type_: GraphQLType | None) -> GraphQLNamedType | None:
         unwrapped_type = type_
         while is_wrapping_type(unwrapped_type):
             unwrapped_type = unwrapped_type.of_type
-        return cast(GraphQLNamedType, unwrapped_type)
+        return cast("GraphQLNamedType", unwrapped_type)
     return None
 
 

src/graphql/type/directives.py

@@ -79,7 +79,7 @@ def __init__(
             locations = tuple(
                 value
                 if isinstance(value, DirectiveLocation)
-                else DirectiveLocation[cast(str, value)]
+                else DirectiveLocation[cast("str", value)]
                 for value in locations
             )
         except (KeyError, TypeError) as error:
@@ -92,7 +92,7 @@ def __init__(
             args = {
                 assert_name(name): value
                 if isinstance(value, GraphQLArgument)
-                else GraphQLArgument(cast(GraphQLInputType, value))
+                else GraphQLArgument(cast("GraphQLInputType", value))
                 for name, value in args.items()
             }
         else:

src/graphql/type/schema.py

@@ -297,11 +297,12 @@ def __deepcopy__(self, memo_: dict) -> GraphQLSchema:
         for directive in directives:
             remap_directive(directive, type_map)
         return self.__class__(
-            self.query_type and cast(GraphQLObjectType, type_map[self.query_type.name]),
+            self.query_type
+            and cast("GraphQLObjectType", type_map[self.query_type.name]),
             self.mutation_type
-            and cast(GraphQLObjectType, type_map[self.mutation_type.name]),
+            and cast("GraphQLObjectType", type_map[self.mutation_type.name]),
             self.subscription_type
-            and cast(GraphQLObjectType, type_map[self.subscription_type.name]),
+            and cast("GraphQLObjectType", type_map[self.subscription_type.name]),
             types,
             directives,
             self.description,
@@ -327,7 +328,7 @@ def get_possible_types(
             abstract_type.types
             if is_union_type(abstract_type)
             else self.get_implementations(
-                cast(GraphQLInterfaceType, abstract_type)
+                cast("GraphQLInterfaceType", abstract_type)
             ).objects
         )
 
@@ -354,7 +355,7 @@ def is_sub_type(
                     add(type_.name)
             else:
                 implementations = self.get_implementations(
-                    cast(GraphQLInterfaceType, abstract_type)
+                    cast("GraphQLInterfaceType", abstract_type)
                 )
                 for type_ in implementations.objects:
                     add(type_.name)
@@ -410,7 +411,7 @@ class TypeSet(Dict[GraphQLNamedType, None]):
 
     @classmethod
     def with_initial_types(cls, types: Collection[GraphQLType]) -> TypeSet:
-        return cast(TypeSet, super().fromkeys(types))
+        return cast("TypeSet", super().fromkeys(types))
 
     def collect_referenced_types(self, type_: GraphQLType) -> None:
         """Recursive function supplementing the type starting from an initial type."""
@@ -455,7 +456,7 @@ def remapped_type(type_: GraphQLType, type_map: TypeMap) -> GraphQLType:
     """Get a copy of the given type that uses this type map."""
     if is_wrapping_type(type_):
         return type_.__class__(remapped_type(type_.of_type, type_map))
-    type_ = cast(GraphQLNamedType, type_)
+    type_ = cast("GraphQLNamedType", type_)
     return type_map.get(type_.name, type_)
 
 
@@ -493,5 +494,5 @@ def remap_directive(directive: GraphQLDirective, type_map: TypeMap) -> None:
     args = directive.args
     for arg_name, arg in args.items():
         arg = copy(arg)  # noqa: PLW2901
-        arg.type = cast(GraphQLInputType, remapped_type(arg.type, type_map))
+        arg.type = cast("GraphQLInputType", remapped_type(arg.type, type_map))
         args[arg_name] = arg