strawberry-graphql 0.275.7__py3-none-any.whl → 0.284.3__py3-none-any.whl

strawberry/types/fields/resolver.py

@@ -10,15 +10,13 @@ from typing import (
     TYPE_CHECKING,
     Annotated,
     Any,
-    Callable,
     Generic,
     NamedTuple,
-    Optional,
     TypeVar,
-    Union,
     cast,
+    get_origin,
 )
-from typing_extensions import Protocol, get_origin
+from typing_extensions import Protocol
 
 from strawberry.annotation import StrawberryAnnotation
 from strawberry.exceptions import (
@@ -33,7 +31,7 @@ from strawberry.utils.typing import type_has_annotation
 
 if TYPE_CHECKING:
     import builtins
-    from collections.abc import Mapping
+    from collections.abc import Callable, Mapping
 
 
 class Parameter(inspect.Parameter):
@@ -63,7 +61,7 @@ class ReservedParameterSpecification(Protocol):
         self,
         parameters: tuple[inspect.Parameter, ...],
         resolver: StrawberryResolver[Any],
-    ) -> Optional[inspect.Parameter]:
+    ) -> inspect.Parameter | None:
         """Finds the reserved parameter from ``parameters``."""
 
 
@@ -74,7 +72,7 @@ class ReservedName(NamedTuple):
         self,
         parameters: tuple[inspect.Parameter, ...],
         resolver: StrawberryResolver[Any],
-    ) -> Optional[inspect.Parameter]:
+    ) -> inspect.Parameter | None:
         del resolver
         return next((p for p in parameters if p.name == self.name), None)
 
@@ -86,7 +84,7 @@ class ReservedNameBoundParameter(NamedTuple):
         self,
         parameters: tuple[inspect.Parameter, ...],
         resolver: StrawberryResolver[Any],
-    ) -> Optional[inspect.Parameter]:
+    ) -> inspect.Parameter | None:
         del resolver
         if parameters:  # Add compatibility for resolvers with no arguments
             first_parameter = parameters[0]
@@ -108,7 +106,7 @@ class ReservedType(NamedTuple):
         self,
         parameters: tuple[inspect.Parameter, ...],
         resolver: StrawberryResolver[Any],
-    ) -> Optional[inspect.Parameter]:
+    ) -> inspect.Parameter | None:
         # Go through all the types even after we've found one so we can
         # give a helpful error message if someone uses the type more than once.
         type_parameters = []
@@ -193,10 +191,10 @@ class StrawberryResolver(Generic[T]):
 
     def __init__(
         self,
-        func: Union[Callable[..., T], staticmethod, classmethod],
+        func: Callable[..., T] | staticmethod | classmethod,
         *,
-        description: Optional[str] = None,
-        type_override: Optional[Union[StrawberryType, type]] = None,
+        description: str | None = None,
+        type_override: StrawberryType | type | None = None,
     ) -> None:
         self.wrapped_func = func
         self._description = description
@@ -220,7 +218,7 @@ class StrawberryResolver(Generic[T]):
     @cached_property
     def strawberry_annotations(
         self,
-    ) -> dict[inspect.Parameter, Union[StrawberryAnnotation, None]]:
+    ) -> dict[inspect.Parameter, StrawberryAnnotation | None]:
         return {
             p: (
                 StrawberryAnnotation(p.annotation, namespace=self._namespace)
@@ -233,7 +231,7 @@ class StrawberryResolver(Generic[T]):
     @cached_property
     def reserved_parameters(
         self,
-    ) -> dict[ReservedParameterSpecification, Optional[inspect.Parameter]]:
+    ) -> dict[ReservedParameterSpecification, inspect.Parameter | None]:
         """Mapping of reserved parameter specification to parameter."""
         parameters = tuple(self.signature.parameters.values())
         return {spec: spec.find(parameters, self) for spec in self.RESERVED_PARAMSPEC}
@@ -281,19 +279,19 @@ class StrawberryResolver(Generic[T]):
         return arguments
 
     @cached_property
-    def info_parameter(self) -> Optional[inspect.Parameter]:
+    def info_parameter(self) -> inspect.Parameter | None:
         return self.reserved_parameters.get(INFO_PARAMSPEC)
 
     @cached_property
-    def root_parameter(self) -> Optional[inspect.Parameter]:
+    def root_parameter(self) -> inspect.Parameter | None:
         return self.reserved_parameters.get(ROOT_PARAMSPEC)
 
     @cached_property
-    def self_parameter(self) -> Optional[inspect.Parameter]:
+    def self_parameter(self) -> inspect.Parameter | None:
         return self.reserved_parameters.get(SELF_PARAMSPEC)
 
     @cached_property
-    def parent_parameter(self) -> Optional[inspect.Parameter]:
+    def parent_parameter(self) -> inspect.Parameter | None:
         return self.reserved_parameters.get(PARENT_PARAMSPEC)
 
     @cached_property
@@ -320,7 +318,7 @@ class StrawberryResolver(Generic[T]):
         }
 
     @cached_property
-    def type_annotation(self) -> Optional[StrawberryAnnotation]:
+    def type_annotation(self) -> StrawberryAnnotation | None:
         return_annotation = self.signature.return_annotation
         if return_annotation is inspect.Signature.empty:
             return None
@@ -329,7 +327,7 @@ class StrawberryResolver(Generic[T]):
         )
 
     @property
-    def type(self) -> Optional[Union[StrawberryType, type]]:
+    def type(self) -> StrawberryType | type | None:
         if self._type_override:
             return self._type_override
         if self.type_annotation is None:
@@ -355,7 +353,7 @@ class StrawberryResolver(Generic[T]):
         )
 
     def copy_with(
-        self, type_var_map: Mapping[str, Union[StrawberryType, builtins.type]]
+        self, type_var_map: Mapping[str, StrawberryType | builtins.type]
     ) -> StrawberryResolver:
         type_override = None
 

strawberry/types/info.py

@@ -7,8 +7,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Generic,
-    Optional,
-    Union,
 )
 from typing_extensions import TypeVar
 
@@ -21,11 +19,7 @@ if TYPE_CHECKING:
 
     from strawberry.schema import Schema
     from strawberry.types.arguments import StrawberryArgument
-    from strawberry.types.base import (
-        StrawberryType,
-        WithStrawberryObjectDefinition,
-    )
-    from strawberry.types.field import StrawberryField
+    from strawberry.types.field import FieldType, StrawberryField
 
     from .nodes import Selection
 
@@ -68,7 +62,7 @@ class Info(Generic[ContextType, RootValueType]):
     _raw_info: GraphQLResolveInfo
     _field: StrawberryField
 
-    def __class_getitem__(cls, types: Union[type, tuple[type, ...]]) -> type[Info]:
+    def __class_getitem__(cls, types: type | tuple[type, ...]) -> type[Info]:
         """Workaround for when passing only one type.
 
         Python doesn't yet support directly passing only one type to a generic class
@@ -78,7 +72,7 @@ class Info(Generic[ContextType, RootValueType]):
         https://discuss.python.org/t/passing-only-one-typevar-of-two-when-using-defaults/49134
         """
         if not isinstance(types, tuple):
-            types = (types, Any)  # type: ignore
+            types = (types, Any)
 
         return super().__class_getitem__(types)  # type: ignore
 
@@ -131,7 +125,7 @@ class Info(Generic[ContextType, RootValueType]):
     @property
     def return_type(
         self,
-    ) -> Optional[Union[type[WithStrawberryObjectDefinition], StrawberryType]]:
+    ) -> FieldType:
         """The return type of the current field being resolved."""
         return self._field.type
 
@@ -154,7 +148,7 @@ class Info(Generic[ContextType, RootValueType]):
     # TODO: parent_type as strawberry types
 
     # Helper functions
-    def get_argument_definition(self, name: str) -> Optional[StrawberryArgument]:
+    def get_argument_definition(self, name: str) -> StrawberryArgument | None:
         """Get the StrawberryArgument definition for the current field by name."""
         try:
             return next(arg for arg in self._field.arguments if arg.python_name == name)

strawberry/types/lazy_type.py

@@ -8,7 +8,6 @@ from typing import (
     Any,
     ForwardRef,
     Generic,
-    Optional,
     TypeVar,
     Union,
     cast,
@@ -32,7 +31,7 @@ class LazyType(Generic[TypeName, Module]):
 
     type_name: str
     module: str
-    package: Optional[str] = None
+    package: str | None = None
 
     def __class_getitem__(cls, params: tuple[str, str]) -> "Self":
         warnings.warn(
@@ -57,7 +56,7 @@ class LazyType(Generic[TypeName, Module]):
         return cls(type_name, module, package)
 
     def __or__(self, other: Other) -> object:
-        return Union[self, other]
+        return Union[self, other]  # noqa: UP007
 
     def resolve_type(self) -> type[Any]:
         module = importlib.import_module(self.module, self.package)

strawberry/types/maybe.py

@@ -1,6 +1,6 @@
+import re
 import typing
-from typing import TYPE_CHECKING, Any, Generic, TypeVar, Union
-from typing_extensions import TypeAlias
+from typing import TYPE_CHECKING, Any, Generic, TypeAlias, TypeVar
 
 T = TypeVar("T")
 
@@ -31,13 +31,22 @@ class Some(Generic[T]):
 
 
 if TYPE_CHECKING:
-    Maybe: TypeAlias = Union[Some[Union[T, None]], None]
+    Maybe: TypeAlias = Some[T] | None
 else:
     # we do this trick so we can inspect that at runtime
     class Maybe(Generic[T]): ...
 
 
+_maybe_re = re.compile(r"^(?:strawberry\.)?Maybe\[(.+)\]$")
+
+
 def _annotation_is_maybe(annotation: Any) -> bool:
+    if isinstance(annotation, str):
+        # Ideally we would try to evaluate the annotation, but the args inside
+        # may still not be available, as the module is still being constructed.
+        # Checking for the pattern should be good enough for now.
+        return _maybe_re.match(annotation) is not None
+
     return (orig := typing.get_origin(annotation)) and orig is Maybe
 
 

strawberry/types/mutation.py

@@ -4,12 +4,9 @@ import dataclasses
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Optional,
-    Union,
+    Literal,
     overload,
 )
-from typing_extensions import Literal
 
 from strawberry.types.field import (
     _RESOLVER_TYPE,
@@ -21,8 +18,8 @@ from strawberry.types.field import (
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping, Sequence
-    from typing_extensions import Literal
+    from collections.abc import Callable, Mapping, Sequence
+    from typing import Literal
 
     from strawberry.extensions.field_extension import FieldExtension
     from strawberry.permission import BasePermission
@@ -35,17 +32,17 @@ if TYPE_CHECKING:
 def mutation(
     *,
     resolver: _RESOLVER_TYPE_ASYNC[T],
-    name: Optional[str] = None,
-    description: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
     init: Literal[False] = False,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
 ) -> T: ...
 
 
@@ -53,34 +50,34 @@ def mutation(
 def mutation(
     *,
     resolver: _RESOLVER_TYPE_SYNC[T],
-    name: Optional[str] = None,
-    description: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
     init: Literal[False] = False,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
 ) -> T: ...
 
 
 @overload
 def mutation(
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
     init: Literal[True] = True,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
 ) -> Any: ...
 
 
@@ -88,16 +85,16 @@ def mutation(
 def mutation(
     resolver: _RESOLVER_TYPE_ASYNC[T],
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
 ) -> StrawberryField: ...
 
 
@@ -105,36 +102,36 @@ def mutation(
 def mutation(
     resolver: _RESOLVER_TYPE_SYNC[T],
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
 ) -> StrawberryField: ...
 
 
 def mutation(
-    resolver: Optional[_RESOLVER_TYPE[Any]] = None,
+    resolver: _RESOLVER_TYPE[Any] | None = None,
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
     # This init parameter is used by PyRight to determine whether this field
     # is added in the constructor or not. It is not used to change
     # any behavior at the moment.
-    init: Literal[True, False, None] = None,
+    init: Literal[True, False] | None = None,
 ) -> Any:
     """Annotates a method or property as a GraphQL mutation.
 
@@ -195,17 +192,17 @@ def mutation(
 def subscription(
     *,
     resolver: _RESOLVER_TYPE_ASYNC[T],
-    name: Optional[str] = None,
-    description: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
     init: Literal[False] = False,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
 ) -> T: ...
 
 
@@ -213,34 +210,34 @@ def subscription(
 def subscription(
     *,
     resolver: _RESOLVER_TYPE_SYNC[T],
-    name: Optional[str] = None,
-    description: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
     init: Literal[False] = False,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
 ) -> T: ...
 
 
 @overload
 def subscription(
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
     init: Literal[True] = True,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
 ) -> Any: ...
 
 
@@ -248,16 +245,16 @@ def subscription(
 def subscription(
     resolver: _RESOLVER_TYPE_ASYNC[T],
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
 ) -> StrawberryField: ...
 
 
@@ -265,33 +262,33 @@ def subscription(
 def subscription(
     resolver: _RESOLVER_TYPE_SYNC[T],
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
 ) -> StrawberryField: ...
 
 
 def subscription(
-    resolver: Optional[_RESOLVER_TYPE[Any]] = None,
+    resolver: _RESOLVER_TYPE[Any] | None = None,
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
-    init: Literal[True, False, None] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
+    init: Literal[True, False] | None = None,
 ) -> Any:
     """Annotates a method or property as a GraphQL subscription.
 

strawberry/types/nodes.py

@@ -12,7 +12,7 @@ Note Python dicts maintain ordering (for all supported versions).
 from __future__ import annotations
 
 import dataclasses
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Union
 
 from graphql.language import FieldNode as GQLFieldNode
 from graphql.language import FragmentSpreadNode as GQLFragmentSpreadNode
@@ -139,7 +139,7 @@ class SelectedField:
     directives: Directives
     arguments: Arguments
     selections: list[Selection]
-    alias: Optional[str] = None
+    alias: str | None = None
 
     @classmethod
     def from_node(cls, info: GraphQLResolveInfo, node: GQLFieldNode) -> SelectedField: