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

strawberry/schema/compat.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 from strawberry.scalars import is_scalar as is_strawberry_scalar
 from strawberry.types.base import StrawberryType, has_object_definition
@@ -11,40 +11,40 @@ from strawberry.types.base import StrawberryType, has_object_definition
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
-    from typing_extensions import TypeGuard
+    from typing import TypeGuard
 
     from strawberry.types.scalar import ScalarDefinition, ScalarWrapper
 
 
-def is_input_type(type_: Union[StrawberryType, type]) -> TypeGuard[type]:
+def is_input_type(type_: StrawberryType | type) -> TypeGuard[type]:
     if not has_object_definition(type_):
         return False
     return type_.__strawberry_definition__.is_input
 
 
-def is_interface_type(type_: Union[StrawberryType, type]) -> TypeGuard[type]:
+def is_interface_type(type_: StrawberryType | type) -> TypeGuard[type]:
     if not has_object_definition(type_):
         return False
     return type_.__strawberry_definition__.is_interface
 
 
 def is_scalar(
-    type_: Union[StrawberryType, type],
-    scalar_registry: Mapping[object, Union[ScalarWrapper, ScalarDefinition]],
+    type_: StrawberryType | type,
+    scalar_registry: Mapping[object, ScalarWrapper | ScalarDefinition],
 ) -> TypeGuard[type]:
     return is_strawberry_scalar(type_, scalar_registry)
 
 
-def is_enum(type_: Union[StrawberryType, type]) -> TypeGuard[type]:
+def is_enum(type_: StrawberryType | type) -> TypeGuard[type]:
     return hasattr(type_, "_enum_definition")
 
 
-def is_schema_directive(type_: Union[StrawberryType, type]) -> TypeGuard[type]:
+def is_schema_directive(type_: StrawberryType | type) -> TypeGuard[type]:
     return hasattr(type_, "__strawberry_directive__")
 
 
 # TODO: do we still need this?
-def is_graphql_generic(type_: Union[StrawberryType, type]) -> bool:
+def is_graphql_generic(type_: StrawberryType | type) -> bool:
     if has_object_definition(type_):
         return type_.__strawberry_definition__.is_graphql_generic
 

strawberry/schema/config.py

@@ -1,12 +1,15 @@
 from __future__ import annotations
 
 from dataclasses import InitVar, dataclass, field
-from typing import Any, Callable, Optional, TypedDict
+from typing import TYPE_CHECKING, Any, TypedDict
 
 from strawberry.types.info import Info
 
 from .name_converter import NameConverter
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
 
 class BatchingConfig(TypedDict):
     max_operations: int
@@ -23,7 +26,7 @@ class StrawberryConfig:
     info_class: type[Info] = Info
     enable_experimental_incremental_execution: bool = False
     _unsafe_disable_same_type_validation: bool = False
-    batching_config: Optional[BatchingConfig] = None
+    batching_config: BatchingConfig | None = None
 
     def __post_init__(
         self,

strawberry/schema/exceptions.py

@@ -1,12 +1,10 @@
-from typing import Optional
-
 from strawberry.types.graphql import OperationType
 
 
 class CannotGetOperationTypeError(Exception):
     """Internal error raised when we cannot get the operation type from a GraphQL document."""
 
-    def __init__(self, operation_name: Optional[str]) -> None:
+    def __init__(self, operation_name: str | None) -> None:
         self.operation_name = operation_name
 
     def as_http_error_reason(self) -> str:

strawberry/schema/name_converter.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional, Union, cast
+from typing import TYPE_CHECKING, cast
 from typing_extensions import Protocol
 
 from strawberry.directive import StrawberryDirective
@@ -26,7 +26,7 @@ if TYPE_CHECKING:
 
 class HasGraphQLName(Protocol):
     python_name: str
-    graphql_name: Optional[str]
+    graphql_name: str | None
 
 
 class NameConverter:
@@ -41,7 +41,7 @@ class NameConverter:
 
     def from_type(
         self,
-        type_: Union[StrawberryType, StrawberryDirective],
+        type_: StrawberryType | StrawberryDirective,
     ) -> str:
         if isinstance(type_, (StrawberryDirective, StrawberrySchemaDirective)):
             return self.from_directive(type_)
@@ -85,7 +85,7 @@ class NameConverter:
         return enum_value.name
 
     def from_directive(
-        self, directive: Union[StrawberryDirective, StrawberrySchemaDirective]
+        self, directive: StrawberryDirective | StrawberrySchemaDirective
     ) -> str:
         name = self.get_graphql_name(directive)
 
@@ -134,7 +134,7 @@ class NameConverter:
     def from_generic(
         self,
         generic_type: StrawberryObjectDefinition,
-        types: list[Union[StrawberryType, type]],
+        types: list[StrawberryType | type],
     ) -> str:
         generic_type_name = generic_type.name
 
@@ -146,7 +146,7 @@ class NameConverter:
 
         return "".join(names) + generic_type_name
 
-    def get_name_from_type(self, type_: Union[StrawberryType, type]) -> str:
+    def get_name_from_type(self, type_: StrawberryType | type) -> str:
         type_ = eval_type(type_)
 
         if isinstance(type_, LazyType):

strawberry/schema/schema.py

@@ -2,16 +2,13 @@ from __future__ import annotations
 
 import warnings
 from asyncio import ensure_future
-from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Iterable
+from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable, Iterable
 from functools import cached_property, lru_cache
 from inspect import isawaitable
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     NamedTuple,
-    Optional,
-    Union,
     cast,
 )
 
@@ -83,7 +80,7 @@ from .exceptions import CannotGetOperationTypeError, InvalidOperationTypeError
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Mapping
-    from typing_extensions import TypeAlias
+    from typing import TypeAlias
 
     from graphql.language import DocumentNode
     from graphql.pyutils import Path
@@ -98,13 +95,12 @@ if TYPE_CHECKING:
     from strawberry.types.union import StrawberryUnion
 
 SubscriptionResult: TypeAlias = AsyncGenerator[
-    Union[PreExecutionError, ExecutionResult], None
+    PreExecutionError | ExecutionResult, None
 ]
 
-OriginSubscriptionResult = Union[
-    OriginalExecutionResult,
-    AsyncIterator[OriginalExecutionResult],
-]
+OriginSubscriptionResult: TypeAlias = (
+    OriginalExecutionResult | AsyncIterator[OriginalExecutionResult]
+)
 
 
 DEFAULT_ALLOWED_OPERATION_TYPES = {
@@ -113,7 +109,7 @@ DEFAULT_ALLOWED_OPERATION_TYPES = {
     OperationType.SUBSCRIPTION,
 }
 ProcessErrors: TypeAlias = (
-    "Callable[[list[GraphQLError], Optional[ExecutionContext]], None]"
+    "Callable[[list[GraphQLError], ExecutionContext | None], None]"
 )
 
 
@@ -150,7 +146,7 @@ def _run_validation(execution_context: ExecutionContext) -> None:
         )
 
 
-def _coerce_error(error: Union[GraphQLError, Exception]) -> GraphQLError:
+def _coerce_error(error: GraphQLError | Exception) -> GraphQLError:
     if isinstance(error, GraphQLError):
         return error
     return GraphQLError(str(error), original_error=error)
@@ -212,16 +208,16 @@ class Schema(BaseSchema):
         # TODO: can we make sure we only allow to pass
         # something that has been decorated?
         query: type,
-        mutation: Optional[type] = None,
-        subscription: Optional[type] = None,
+        mutation: type | None = None,
+        subscription: type | None = None,
         directives: Iterable[StrawberryDirective] = (),
-        types: Iterable[Union[type, StrawberryType]] = (),
-        extensions: Iterable[Union[type[SchemaExtension], SchemaExtension]] = (),
-        execution_context_class: Optional[type[GraphQLExecutionContext]] = None,
-        config: Optional[StrawberryConfig] = None,
-        scalar_overrides: Optional[
-            Mapping[object, Union[type, ScalarWrapper, ScalarDefinition]],
-        ] = None,
+        types: Iterable[type | StrawberryType] = (),
+        extensions: Iterable[type[SchemaExtension] | SchemaExtension] = (),
+        execution_context_class: type[GraphQLExecutionContext] | None = None,
+        config: StrawberryConfig | None = None,
+        scalar_overrides: (
+            Mapping[object, type | ScalarWrapper | ScalarDefinition] | None
+        ) = None,
         schema_directives: Iterable[object] = (),
     ) -> None:
         """Default Schema to be used in a Strawberry application.
@@ -398,7 +394,7 @@ class Schema(BaseSchema):
         )
 
     def _get_custom_context_kwargs(
-        self, operation_extensions: Optional[dict[str, Any]] = None
+        self, operation_extensions: dict[str, Any] | None = None
     ) -> dict[str, Any]:
         if not IS_GQL_33:
             return {}
@@ -417,13 +413,13 @@ class Schema(BaseSchema):
 
     def _create_execution_context(
         self,
-        query: Optional[str],
+        query: str | None,
         allowed_operation_types: Iterable[OperationType],
-        variable_values: Optional[dict[str, Any]] = None,
-        context_value: Optional[Any] = None,
-        root_value: Optional[Any] = None,
-        operation_name: Optional[str] = None,
-        operation_extensions: Optional[dict[str, Any]] = None,
+        variable_values: dict[str, Any] | None = None,
+        context_value: Any | None = None,
+        root_value: Any | None = None,
+        operation_name: str | None = None,
+        operation_extensions: dict[str, Any] | None = None,
     ) -> ExecutionContext:
         return ExecutionContext(
             query=query,
@@ -439,14 +435,13 @@ class Schema(BaseSchema):
     @lru_cache
     def get_type_by_name(
         self, name: str
-    ) -> Optional[
-        Union[
-            StrawberryObjectDefinition,
-            ScalarDefinition,
-            EnumDefinition,
-            StrawberryUnion,
-        ]
-    ]:
+    ) -> (
+        StrawberryObjectDefinition
+        | ScalarDefinition
+        | EnumDefinition
+        | StrawberryUnion
+        | None
+    ):
         # TODO: respect auto_camel_case
         if name in self.schema_converter.type_map:
             return self.schema_converter.type_map[name].definition
@@ -455,7 +450,7 @@ class Schema(BaseSchema):
 
     def get_field_for_type(
         self, field_name: str, type_name: str
-    ) -> Optional[StrawberryField]:
+    ) -> StrawberryField | None:
         type_ = self.get_type_by_name(type_name)
 
         if not type_:
@@ -473,7 +468,7 @@ class Schema(BaseSchema):
         )
 
     @lru_cache
-    def get_directive_by_name(self, graphql_name: str) -> Optional[StrawberryDirective]:
+    def get_directive_by_name(self, graphql_name: str) -> StrawberryDirective | None:
         return next(
             (
                 directive
@@ -490,7 +485,7 @@ class Schema(BaseSchema):
 
     async def _parse_and_validate_async(
         self, context: ExecutionContext, extensions_runner: SchemaExtensionsRunner
-    ) -> Optional[PreExecutionError]:
+    ) -> PreExecutionError | None:
         if not context.query:
             raise MissingQueryError
 
@@ -553,13 +548,13 @@ class Schema(BaseSchema):
 
     async def execute(
         self,
-        query: Optional[str],
-        variable_values: Optional[dict[str, Any]] = None,
-        context_value: Optional[Any] = None,
-        root_value: Optional[Any] = None,
-        operation_name: Optional[str] = None,
-        allowed_operation_types: Optional[Iterable[OperationType]] = None,
-        operation_extensions: Optional[dict[str, Any]] = None,
+        query: str | None,
+        variable_values: dict[str, Any] | None = None,
+        context_value: Any | None = None,
+        root_value: Any | None = None,
+        operation_name: str | None = None,
+        allowed_operation_types: Iterable[OperationType] | None = None,
+        operation_extensions: dict[str, Any] | None = None,
     ) -> ExecutionResult:
         if allowed_operation_types is None:
             allowed_operation_types = DEFAULT_ALLOWED_OPERATION_TYPES
@@ -659,13 +654,13 @@ class Schema(BaseSchema):
 
     def execute_sync(
         self,
-        query: Optional[str],
-        variable_values: Optional[dict[str, Any]] = None,
-        context_value: Optional[Any] = None,
-        root_value: Optional[Any] = None,
-        operation_name: Optional[str] = None,
-        allowed_operation_types: Optional[Iterable[OperationType]] = None,
-        operation_extensions: Optional[dict[str, Any]] = None,
+        query: str | None,
+        variable_values: dict[str, Any] | None = None,
+        context_value: Any | None = None,
+        root_value: Any | None = None,
+        operation_name: str | None = None,
+        allowed_operation_types: Iterable[OperationType] | None = None,
+        operation_extensions: dict[str, Any] | None = None,
     ) -> ExecutionResult:
         if allowed_operation_types is None:
             allowed_operation_types = DEFAULT_ALLOWED_OPERATION_TYPES
@@ -805,7 +800,7 @@ class Schema(BaseSchema):
         extensions_runner: SchemaExtensionsRunner,
         middleware_manager: MiddlewareManager,
         execution_context_class: type[GraphQLExecutionContext] | None = None,
-        operation_extensions: Optional[dict[str, Any]] = None,
+        operation_extensions: dict[str, Any] | None = None,
     ) -> AsyncGenerator[ExecutionResult, None]:
         async with extensions_runner.operation():
             if initial_error := await self._parse_and_validate_async(
@@ -884,12 +879,12 @@ class Schema(BaseSchema):
 
     async def subscribe(
         self,
-        query: Optional[str],
-        variable_values: Optional[dict[str, Any]] = None,
-        context_value: Optional[Any] = None,
-        root_value: Optional[Any] = None,
-        operation_name: Optional[str] = None,
-        operation_extensions: Optional[dict[str, Any]] = None,
+        query: str | None,
+        variable_values: dict[str, Any] | None = None,
+        context_value: Any | None = None,
+        root_value: Any | None = None,
+        operation_name: str | None = None,
+        operation_extensions: dict[str, Any] | None = None,
     ) -> SubscriptionResult:
         execution_context = self._create_execution_context(
             query=query,

strawberry/schema/schema_converter.py

@@ -2,15 +2,14 @@ from __future__ import annotations
 
 import dataclasses
 import sys
+import typing
 from functools import partial, reduce
 from typing import (
     TYPE_CHECKING,
+    Annotated,
     Any,
-    Callable,
     Generic,
-    Optional,
     TypeVar,
-    Union,
     cast,
 )
 from typing_extensions import Protocol
@@ -80,7 +79,7 @@ from . import compat
 from .types.concrete_type import ConcreteType
 
 if TYPE_CHECKING:
-    from collections.abc import Awaitable, Mapping
+    from collections.abc import Awaitable, Callable, Mapping
 
     from graphql import (
         GraphQLInputType,
@@ -100,17 +99,17 @@ if TYPE_CHECKING:
 
 FieldType = TypeVar(
     "FieldType",
-    bound=Union[GraphQLField, GraphQLInputField],
+    bound=GraphQLField | GraphQLInputField,
     covariant=True,
 )
 
 
-class FieldConverterProtocol(Generic[FieldType], Protocol):
+class FieldConverterProtocol(Protocol, Generic[FieldType]):
     def __call__(  # pragma: no cover
         self,
         field: StrawberryField,
         *,
-        type_definition: Optional[StrawberryObjectDefinition] = None,
+        type_definition: StrawberryObjectDefinition | None = None,
     ) -> FieldType: ...
 
 
@@ -180,7 +179,7 @@ class CustomGraphQLEnumType(GraphQLEnumType):
         return self.wrapped_cls(super().parse_value(input_value))
 
     def parse_literal(
-        self, value_node: ValueNode, _variables: Optional[dict[str, Any]] = None
+        self, value_node: ValueNode, _variables: dict[str, Any] | None = None
     ) -> Any:
         return self.wrapped_cls(super().parse_literal(value_node, _variables))
 
@@ -192,7 +191,7 @@ def get_arguments(
     info: Info,
     kwargs: Any,
     config: StrawberryConfig,
-    scalar_registry: Mapping[object, Union[ScalarWrapper, ScalarDefinition]],
+    scalar_registry: Mapping[object, ScalarWrapper | ScalarDefinition],
 ) -> tuple[list[Any], dict[str, Any]]:
     # TODO: An extension might have changed the resolver arguments,
     # but we need them here since we are calling it.
@@ -249,7 +248,7 @@ class GraphQLCoreConverter:
     def __init__(
         self,
         config: StrawberryConfig,
-        scalar_overrides: Mapping[object, Union[ScalarWrapper, ScalarDefinition]],
+        scalar_overrides: Mapping[object, ScalarWrapper | ScalarDefinition],
         get_fields: Callable[[StrawberryObjectDefinition], list[StrawberryField]],
     ) -> None:
         self.type_map: dict[str, ConcreteType] = {}
@@ -259,8 +258,8 @@ class GraphQLCoreConverter:
 
     def _get_scalar_registry(
         self,
-        scalar_overrides: Mapping[object, Union[ScalarWrapper, ScalarDefinition]],
-    ) -> Mapping[object, Union[ScalarWrapper, ScalarDefinition]]:
+        scalar_overrides: Mapping[object, ScalarWrapper | ScalarDefinition],
+    ) -> Mapping[object, ScalarWrapper | ScalarDefinition]:
         scalar_registry = {**DEFAULT_SCALAR_REGISTRY}
 
         global_id_name = "GlobalID" if self.config.relay_use_legacy_global_id else "ID"
@@ -407,7 +406,7 @@ class GraphQLCoreConverter:
         self,
         field: StrawberryField,
         *,
-        type_definition: Optional[StrawberryObjectDefinition] = None,
+        type_definition: StrawberryObjectDefinition | None = None,
     ) -> GraphQLField:
         # self.from_resolver needs to be called before accessing field.type because
         # in there a field extension might want to change the type during its apply
@@ -445,7 +444,7 @@ class GraphQLCoreConverter:
         self,
         field: StrawberryField,
         *,
-        type_definition: Optional[StrawberryObjectDefinition] = None,
+        type_definition: StrawberryObjectDefinition | None = None,
     ) -> GraphQLInputField:
         field_type = cast(
             "GraphQLInputType",
@@ -556,14 +555,14 @@ class GraphQLCoreConverter:
 
         def _get_resolve_type() -> Callable[
             [Any, GraphQLResolveInfo, GraphQLAbstractType],
-            Union[Awaitable[Optional[str]], str, None],
+            Awaitable[str | None] | str | None,
         ]:
             if interface.resolve_type:
                 return interface.resolve_type
 
             def resolve_type(
                 obj: Any, info: GraphQLResolveInfo, abstract_type: GraphQLAbstractType
-            ) -> Union[Awaitable[Optional[str]], str, None]:
+            ) -> Awaitable[str | None] | str | None:
                 if isinstance(obj, interface.origin):
                     type_definition = get_object_definition(obj, strict=True)
 
@@ -578,7 +577,7 @@ class GraphQLCoreConverter:
                     # all the types in the schema, but we should probably
                     # optimize this
 
-                    return_type: Optional[GraphQLType] = None
+                    return_type: GraphQLType | None = None
 
                     for possible_concrete_type in self.type_map.values():
                         possible_type = possible_concrete_type.definition
@@ -639,7 +638,7 @@ class GraphQLCoreConverter:
             assert isinstance(graphql_object_type, GraphQLObjectType)  # For mypy
             return graphql_object_type
 
-        def _get_is_type_of() -> Optional[Callable[[Any, GraphQLResolveInfo], bool]]:
+        def _get_is_type_of() -> Callable[[Any, GraphQLResolveInfo], bool] | None:
             if object_type.is_type_of:
                 return object_type.is_type_of
 
@@ -849,8 +848,8 @@ class GraphQLCoreConverter:
         return implementation
 
     def from_maybe_optional(
-        self, type_: Union[StrawberryType, type]
-    ) -> Union[GraphQLNullableType, GraphQLNonNull]:
+        self, type_: StrawberryType | type
+    ) -> GraphQLNullableType | GraphQLNonNull:
         NoneType = type(None)
         if type_ is None or type_ is NoneType:
             return self.from_type(type_)
@@ -865,10 +864,16 @@ class GraphQLCoreConverter:
             return self.from_type(type_.of_type)
         return GraphQLNonNull(self.from_type(type_))
 
-    def from_type(self, type_: Union[StrawberryType, type]) -> GraphQLNullableType:
+    def from_type(self, type_: StrawberryType | type) -> GraphQLNullableType:
         if compat.is_graphql_generic(type_):
             raise MissingTypesForGenericError(type_)
 
+        # to handle lazy unions
+        if typing.get_origin(type_) is Annotated:
+            args = typing.get_args(type_)
+            if len(args) >= 2 and isinstance(args[1], StrawberryUnion):
+                type_ = args[1]
+
         if isinstance(type_, EnumDefinition):  # TODO: Replace with StrawberryEnum
             return self.from_enum(type_)
         if compat.is_input_type(type_):  # TODO: Replace with StrawberryInputObject
@@ -952,7 +957,7 @@ class GraphQLCoreConverter:
     def _get_is_type_of(
         self,
         object_type: StrawberryObjectDefinition,
-    ) -> Optional[Callable[[Any, GraphQLResolveInfo], bool]]:
+    ) -> Callable[[Any, GraphQLResolveInfo], bool] | None:
         if object_type.is_type_of:
             return object_type.is_type_of
 

strawberry/schema/types/base_scalars.py

@@ -1,8 +1,8 @@
 import datetime
 import decimal
 import uuid
+from collections.abc import Callable
 from operator import methodcaller
-from typing import Callable
 
 import dateutil.parser
 from graphql import GraphQLError

strawberry/schema/types/concrete_type.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, TypeAlias
 
 from graphql import GraphQLField, GraphQLInputField, GraphQLType
 
@@ -11,14 +11,14 @@ if TYPE_CHECKING:
     from strawberry.types.scalar import ScalarDefinition
     from strawberry.types.union import StrawberryUnion
 
-Field = Union[GraphQLInputField, GraphQLField]
+Field: TypeAlias = GraphQLInputField | GraphQLField
 
 
 @dataclasses.dataclass
 class ConcreteType:
-    definition: Union[
-        StrawberryObjectDefinition, EnumDefinition, ScalarDefinition, StrawberryUnion
-    ]
+    definition: (
+        StrawberryObjectDefinition | EnumDefinition | ScalarDefinition | StrawberryUnion
+    )
     implementation: GraphQLType
 
 

strawberry/schema_codegen/__init__.py

@@ -4,8 +4,8 @@ import dataclasses
 import keyword
 from collections import defaultdict
 from graphlib import TopologicalSorter
-from typing import TYPE_CHECKING, Union
-from typing_extensions import Protocol, TypeAlias
+from typing import TYPE_CHECKING, TypeAlias
+from typing_extensions import Protocol
 
 import libcst as cst
 from graphql import (
@@ -256,7 +256,7 @@ def _get_field(
     )
 
 
-ArgumentValue: TypeAlias = Union[str, bool, list["ArgumentValue"]]
+ArgumentValue: TypeAlias = str | bool | list["ArgumentValue"]
 
 
 def _get_argument_value(argument_value: ConstValueNode) -> ArgumentValue:

strawberry/schema_directive.py

@@ -1,6 +1,7 @@
 import dataclasses
+from collections.abc import Callable
 from enum import Enum
-from typing import Callable, Optional, TypeVar
+from typing import TypeVar
 from typing_extensions import dataclass_transform
 
 from strawberry.types.field import StrawberryField, field
@@ -27,13 +28,13 @@ class Location(Enum):
 @dataclasses.dataclass
 class StrawberrySchemaDirective:
     python_name: str
-    graphql_name: Optional[str]
+    graphql_name: str | None
     locations: list[Location]
     fields: list["StrawberryField"]
-    description: Optional[str] = None
+    description: str | None = None
     repeatable: bool = False
     print_definition: bool = True
-    origin: Optional[type] = None
+    origin: type | None = None
 
 
 T = TypeVar("T", bound=type)
@@ -47,8 +48,8 @@ T = TypeVar("T", bound=type)
 def schema_directive(
     *,
     locations: list[Location],
-    description: Optional[str] = None,
-    name: Optional[str] = None,
+    description: str | None = None,
+    name: str | None = None,
     repeatable: bool = False,
     print_definition: bool = True,
 ) -> Callable[[T], T]: