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

strawberry/extensions/base_extension.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
 from strawberry.utils.await_maybe import AsyncIteratorOrIterator, AwaitableOrValue
 

strawberry/extensions/context.py

@@ -8,17 +8,14 @@ from asyncio import iscoroutinefunction
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     NamedTuple,
-    Optional,
-    Union,
 )
 
 from strawberry.extensions import SchemaExtension
 from strawberry.utils.await_maybe import AwaitableOrValue, await_maybe
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncIterator, Iterator
+    from collections.abc import AsyncIterator, Callable, Iterator
     from types import TracebackType
 
     from strawberry.extensions.base_extension import Hook
@@ -28,10 +25,8 @@ class WrappedHook(NamedTuple):
     extension: SchemaExtension
     hook: Callable[
         ...,
-        Union[
-            contextlib.AbstractAsyncContextManager[None],
-            contextlib.AbstractContextManager[None],
-        ],
+        contextlib.AbstractAsyncContextManager[None]
+        | contextlib.AbstractContextManager[None],
     ]
     is_async: bool
 
@@ -65,12 +60,12 @@ class ExtensionContextManagerBase:
             if hook:
                 self.hooks.append(hook)
 
-    def get_hook(self, extension: SchemaExtension) -> Optional[WrappedHook]:
+    def get_hook(self, extension: SchemaExtension) -> WrappedHook | None:
         on_start = getattr(extension, self.LEGACY_ENTER, None)
         on_end = getattr(extension, self.LEGACY_EXIT, None)
 
         is_legacy = on_start is not None or on_end is not None
-        hook_fn: Optional[Hook] = getattr(type(extension), self.HOOK_NAME)
+        hook_fn: Hook | None = getattr(type(extension), self.HOOK_NAME)
         hook_fn = hook_fn if hook_fn is not self.default_hook else None
         if is_legacy and hook_fn is not None:
             raise ValueError(
@@ -111,8 +106,8 @@ class ExtensionContextManagerBase:
     @staticmethod
     def from_legacy(
         extension: SchemaExtension,
-        on_start: Optional[Callable[[], None]] = None,
-        on_end: Optional[Callable[[], None]] = None,
+        on_start: Callable[[], None] | None = None,
+        on_end: Callable[[], None] | None = None,
     ) -> WrappedHook:
         if iscoroutinefunction(on_start) or iscoroutinefunction(on_end):
 
@@ -176,9 +171,9 @@ class ExtensionContextManagerBase:
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         self.exit_stack.__exit__(exc_type, exc_val, exc_tb)
 
@@ -195,9 +190,9 @@ class ExtensionContextManagerBase:
 
     async def __aexit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         await self.async_exit_stack.__aexit__(exc_type, exc_val, exc_tb)
 

strawberry/extensions/directives.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
 from strawberry.extensions import SchemaExtension
 from strawberry.types.nodes import convert_arguments
 from strawberry.utils.await_maybe import await_maybe
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from graphql import DirectiveNode, GraphQLResolveInfo
 
     from strawberry.directive import StrawberryDirective

strawberry/extensions/field_extension.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
 import itertools
-from collections.abc import Awaitable
+from collections.abc import Awaitable, Callable
 from functools import cached_property
-from typing import TYPE_CHECKING, Any, Callable, Union
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from typing_extensions import TypeAlias
+    from typing import TypeAlias
 
     from strawberry.types import Info
     from strawberry.types.field import StrawberryField
@@ -69,7 +69,7 @@ def _get_async_resolvers(
 
 def build_field_extension_resolvers(
     field: StrawberryField,
-) -> list[Union[SyncExtensionResolver, AsyncExtensionResolver]]:
+) -> list[SyncExtensionResolver | AsyncExtensionResolver]:
     """Builds a list of resolvers for a field with extensions.
 
     Verifies that all of the field extensions for a given field support

strawberry/extensions/max_aliases.py

@@ -1,5 +1,3 @@
-from typing import Union
-
 from graphql import (
     ExecutableDefinitionNode,
     FieldNode,
@@ -64,7 +62,7 @@ def create_validator(max_alias_count: int) -> type[ValidationRule]:
 
 
 def count_fields_with_alias(
-    selection_set_owner: Union[ExecutableDefinitionNode, FieldNode, InlineFragmentNode],
+    selection_set_owner: ExecutableDefinitionNode | FieldNode | InlineFragmentNode,
 ) -> int:
     if selection_set_owner.selection_set is None:
         return 0

strawberry/extensions/parser_cache.py

@@ -1,6 +1,5 @@
 from collections.abc import Iterator
 from functools import lru_cache
-from typing import Optional
 
 from graphql.language.parser import parse
 
@@ -25,7 +24,7 @@ class ParserCache(SchemaExtension):
     ```
     """
 
-    def __init__(self, maxsize: Optional[int] = None) -> None:
+    def __init__(self, maxsize: int | None = None) -> None:
         """Initialize the ParserCache.
 
         Args:

strawberry/extensions/query_depth_limiter.py

@@ -28,12 +28,11 @@
 from __future__ import annotations
 
 import re
+from collections.abc import Callable
 from dataclasses import dataclass
 from typing import (
     TYPE_CHECKING,
-    Callable,
-    Optional,
-    Union,
+    TypeAlias,
 )
 
 from graphql import GraphQLError
@@ -61,12 +60,17 @@ from strawberry.extensions.utils import is_introspection_key
 if TYPE_CHECKING:
     from collections.abc import Iterable
 
-IgnoreType = Union[Callable[[str], bool], re.Pattern, str]
+IgnoreType: TypeAlias = Callable[[str], bool] | re.Pattern | str
 
-FieldArgumentType = Union[
-    bool, int, float, str, list["FieldArgumentType"], dict[str, "FieldArgumentType"]
-]
-FieldArgumentsType = dict[str, FieldArgumentType]
+FieldArgumentType: TypeAlias = (
+    bool
+    | int
+    | float
+    | str
+    | list["FieldArgumentType"]
+    | dict[str, "FieldArgumentType"]
+)
+FieldArgumentsType: TypeAlias = dict[str, FieldArgumentType]
 
 
 @dataclass
@@ -99,8 +103,8 @@ class QueryDepthLimiter(AddValidationRules):
     def __init__(
         self,
         max_depth: int,
-        callback: Optional[Callable[[dict[str, int]], None]] = None,
-        should_ignore: Optional[ShouldIgnoreType] = None,
+        callback: Callable[[dict[str, int]], None] | None = None,
+        should_ignore: ShouldIgnoreType | None = None,
     ) -> None:
         """Initialize the QueryDepthLimiter.
 
@@ -122,8 +126,8 @@ class QueryDepthLimiter(AddValidationRules):
 
 def create_validator(
     max_depth: int,
-    should_ignore: Optional[ShouldIgnoreType],
-    callback: Optional[Callable[[dict[str, int]], None]] = None,
+    should_ignore: ShouldIgnoreType | None,
+    callback: Callable[[dict[str, int]], None] | None = None,
 ) -> type[ValidationRule]:
     class DepthLimitValidator(ValidationRule):
         def __init__(self, validation_context: ValidationContext) -> None:
@@ -218,7 +222,7 @@ def determine_depth(
     max_depth: int,
     context: ValidationContext,
     operation_name: str,
-    should_ignore: Optional[ShouldIgnoreType],
+    should_ignore: ShouldIgnoreType | None,
 ) -> int:
     if depth_so_far > max_depth:
         context.report_error(
@@ -288,7 +292,7 @@ def determine_depth(
     raise TypeError(f"Depth crawler cannot handle: {node.kind}")  # pragma: no cover
 
 
-def is_ignored(node: FieldNode, ignore: Optional[list[IgnoreType]] = None) -> bool:
+def is_ignored(node: FieldNode, ignore: list[IgnoreType] | None = None) -> bool:
     if ignore is None:
         return False
 

strawberry/extensions/runner.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import inspect
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from strawberry.extensions.context import (
     ExecutingContextManager,
@@ -23,7 +23,7 @@ class SchemaExtensionsRunner:
     def __init__(
         self,
         execution_context: ExecutionContext,
-        extensions: Optional[list[SchemaExtension]] = None,
+        extensions: list[SchemaExtension] | None = None,
     ) -> None:
         self.execution_context = execution_context
         self.extensions = extensions or []

strawberry/extensions/tracing/apollo.py

@@ -4,7 +4,7 @@ import dataclasses
 import time
 from datetime import datetime, timezone
 from inspect import isawaitable
-from typing import TYPE_CHECKING, Any, Callable, Optional
+from typing import TYPE_CHECKING, Any
 
 from strawberry.extensions import SchemaExtension
 from strawberry.extensions.utils import get_path_from_info
@@ -12,7 +12,7 @@ from strawberry.extensions.utils import get_path_from_info
 from .utils import should_skip_tracing
 
 if TYPE_CHECKING:
-    from collections.abc import Generator
+    from collections.abc import Callable, Generator
 
     from graphql import GraphQLResolveInfo
 
@@ -38,7 +38,7 @@ class ApolloResolverStats:
     field_name: str
     return_type: Any
     start_offset: int
-    duration: Optional[int] = None
+    duration: int | None = None
 
     def to_json(self) -> dict[str, Any]:
         return {

strawberry/extensions/tracing/datadog.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import hashlib
 from functools import cached_property
 from inspect import isawaitable
-from typing import TYPE_CHECKING, Any, Callable, Optional
+from typing import TYPE_CHECKING, Any
 
 import ddtrace
 from packaging import version
@@ -19,7 +19,7 @@ else:
 
 
 if TYPE_CHECKING:
-    from collections.abc import Generator, Iterator
+    from collections.abc import Callable, Generator, Iterator
 
     from graphql import GraphQLResolveInfo
 
@@ -30,7 +30,7 @@ class DatadogTracingExtension(SchemaExtension):
     def __init__(
         self,
         *,
-        execution_context: Optional[ExecutionContext] = None,
+        execution_context: ExecutionContext | None = None,
     ) -> None:
         if execution_context:
             self.execution_context = execution_context

strawberry/extensions/tracing/opentelemetry.py

@@ -1,13 +1,11 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from copy import deepcopy
 from inspect import isawaitable
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Optional,
-    Union,
 )
 
 from opentelemetry import trace
@@ -33,16 +31,16 @@ ArgFilter = Callable[[dict[str, Any], "GraphQLResolveInfo"], dict[str, Any]]
 
 
 class OpenTelemetryExtension(SchemaExtension):
-    _arg_filter: Optional[ArgFilter]
+    _arg_filter: ArgFilter | None
     _span_holder: dict[LifecycleStep, Span]
     _tracer: Tracer
 
     def __init__(
         self,
         *,
-        execution_context: Optional[ExecutionContext] = None,
-        arg_filter: Optional[ArgFilter] = None,
-        tracer_provider: Optional[trace.TracerProvider] = None,
+        execution_context: ExecutionContext | None = None,
+        arg_filter: ArgFilter | None = None,
+        tracer_provider: trace.TracerProvider | None = None,
     ) -> None:
         self._arg_filter = arg_filter
         self._tracer = trace.get_tracer("strawberry", tracer_provider=tracer_provider)
@@ -129,7 +127,7 @@ class OpenTelemetryExtension(SchemaExtension):
             return bytes(value)  # Convert bytearray and memoryview to bytes
         return str(value)
 
-    def convert_set_to_allowed_types(self, value: Union[set, frozenset]) -> str:
+    def convert_set_to_allowed_types(self, value: set | frozenset) -> str:
         return (
             "{" + ", ".join(str(self.convert_to_allowed_types(x)) for x in value) + "}"
         )

strawberry/extensions/tracing/utils.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
 from strawberry.extensions.utils import is_introspection_field
 from strawberry.resolvers import is_default_resolver
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from graphql import GraphQLResolveInfo
 
 

strawberry/extensions/utils.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
 
 
-def is_introspection_key(key: Union[str, int]) -> bool:
+def is_introspection_key(key: str | int) -> bool:
     # from: https://spec.graphql.org/June2018/#sec-Schema
     # > All types and directives defined within a schema must not have a name which
     # > begins with "__" (two underscores), as this is used exclusively

strawberry/extensions/validation_cache.py

@@ -1,6 +1,5 @@
 from collections.abc import Iterator
 from functools import lru_cache
-from typing import Optional
 
 from strawberry.extensions.base_extension import SchemaExtension
 
@@ -22,7 +21,7 @@ class ValidationCache(SchemaExtension):
     ```
     """
 
-    def __init__(self, maxsize: Optional[int] = None) -> None:
+    def __init__(self, maxsize: int | None = None) -> None:
         """Initialize the ValidationCache.
 
         Args:

strawberry/fastapi/context.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional, Union
+from typing import Any, Union
 
 from starlette.background import BackgroundTasks
 from starlette.requests import Request
@@ -7,17 +7,17 @@ from starlette.websockets import WebSocket
 
 CustomContext = Union["BaseContext", dict[str, Any]]
 MergedContext = Union[
-    "BaseContext", dict[str, Union[Any, BackgroundTasks, Request, Response, WebSocket]]
+    "BaseContext", dict[str, Any | BackgroundTasks | Request | Response | WebSocket]
 ]
 
 
 class BaseContext:
-    connection_params: Optional[Any] = None
+    connection_params: Any | None = None
 
     def __init__(self) -> None:
-        self.request: Optional[Union[Request, WebSocket]] = None
-        self.background_tasks: Optional[BackgroundTasks] = None
-        self.response: Optional[Response] = None
+        self.request: Request | WebSocket | None = None
+        self.background_tasks: BackgroundTasks | None = None
+        self.response: Response | None = None
 
 
 __all__ = ["BaseContext"]

strawberry/fastapi/router.py

@@ -6,13 +6,14 @@ from inspect import signature
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Optional,
-    Union,
+    TypeGuard,
     cast,
 )
-from typing_extensions import TypeGuard
 
+from fastapi import APIRouter, Depends, params
+from fastapi.datastructures import Default
+from fastapi.routing import APIRoute
+from fastapi.utils import generate_unique_id
 from lia import HTTPException, StarletteRequestAdapter
 from starlette import status
 from starlette.background import BackgroundTasks  # noqa: TC002
@@ -26,10 +27,6 @@ from starlette.responses import (
 )
 from starlette.websockets import WebSocket
 
-from fastapi import APIRouter, Depends, params
-from fastapi.datastructures import Default
-from fastapi.routing import APIRoute
-from fastapi.utils import generate_unique_id
 from strawberry.asgi import ASGIWebSocketAdapter
 from strawberry.exceptions import InvalidCustomContext
 from strawberry.fastapi.context import BaseContext, CustomContext
@@ -41,6 +38,7 @@ if TYPE_CHECKING:
     from collections.abc import (
         AsyncIterator,
         Awaitable,
+        Callable,
         Sequence,
     )
     from enum import Enum
@@ -62,7 +60,7 @@ class GraphQLRouter(
 ):
     allow_queries_via_get = True
     request_adapter_class = StarletteRequestAdapter
-    websocket_adapter_class = ASGIWebSocketAdapter
+    websocket_adapter_class = ASGIWebSocketAdapter  # type: ignore
 
     @staticmethod
     async def __get_root_value() -> None:
@@ -71,16 +69,16 @@ class GraphQLRouter(
     @staticmethod
     def __get_context_getter(
         custom_getter: Callable[
-            ..., Union[Optional[CustomContext], Awaitable[Optional[CustomContext]]]
+            ..., CustomContext | None | Awaitable[CustomContext | None]
         ],
     ) -> Callable[..., Awaitable[CustomContext]]:
         async def dependency(
-            custom_context: Optional[CustomContext],
+            custom_context: CustomContext | None,
             background_tasks: BackgroundTasks,
             connection: HTTPConnection,
             response: Response = None,  # type: ignore
         ) -> MergedContext:
-            request = cast("Union[Request, WebSocket]", connection)
+            request = cast("Request | WebSocket", connection)
             if isinstance(custom_context, BaseContext):
                 custom_context.request = request
                 custom_context.background_tasks = background_tasks
@@ -122,35 +120,34 @@ class GraphQLRouter(
         self,
         schema: BaseSchema,
         path: str = "",
-        graphiql: Optional[bool] = None,
-        graphql_ide: Optional[GraphQL_IDE] = "graphiql",
+        graphiql: bool | None = None,
+        graphql_ide: GraphQL_IDE | None = "graphiql",
         allow_queries_via_get: bool = True,
         keep_alive: bool = False,
         keep_alive_interval: float = 1,
-        root_value_getter: Optional[Callable[[], RootValue]] = None,
-        context_getter: Optional[
-            Callable[..., Union[Optional[Context], Awaitable[Optional[Context]]]]
-        ] = None,
+        root_value_getter: Callable[[], RootValue] | None = None,
+        context_getter: Callable[..., Context | None | Awaitable[Context | None]]
+        | None = None,
         subscription_protocols: Sequence[str] = (
             GRAPHQL_TRANSPORT_WS_PROTOCOL,
             GRAPHQL_WS_PROTOCOL,
         ),
         connection_init_wait_timeout: timedelta = timedelta(minutes=1),
         prefix: str = "",
-        tags: Optional[list[Union[str, Enum]]] = None,
-        dependencies: Optional[Sequence[params.Depends]] = None,
+        tags: list[str | Enum] | None = None,
+        dependencies: Sequence[params.Depends] | None = None,
         default_response_class: type[Response] = Default(JSONResponse),
-        responses: Optional[dict[Union[int, str], dict[str, Any]]] = None,
-        callbacks: Optional[list[BaseRoute]] = None,
-        routes: Optional[list[BaseRoute]] = None,
+        responses: dict[int | str, dict[str, Any]] | None = None,
+        callbacks: list[BaseRoute] | None = None,
+        routes: list[BaseRoute] | None = None,
         redirect_slashes: bool = True,
-        default: Optional[ASGIApp] = None,
-        dependency_overrides_provider: Optional[Any] = None,
+        default: ASGIApp | None = None,
+        dependency_overrides_provider: Any | None = None,
         route_class: type[APIRoute] = APIRoute,
-        on_startup: Optional[Sequence[Callable[[], Any]]] = None,
-        on_shutdown: Optional[Sequence[Callable[[], Any]]] = None,
-        lifespan: Optional[Lifespan[Any]] = None,
-        deprecated: Optional[bool] = None,
+        on_startup: Sequence[Callable[[], Any]] | None = None,
+        on_shutdown: Sequence[Callable[[], Any]] | None = None,
+        lifespan: Lifespan[Any] | None = None,
+        deprecated: bool | None = None,
         include_in_schema: bool = True,
         generate_unique_id_function: Callable[[APIRoute], str] = Default(
             generate_unique_id
@@ -265,13 +262,13 @@ class GraphQLRouter(
         return HTMLResponse(self.graphql_ide_html)
 
     async def get_context(
-        self, request: Union[Request, WebSocket], response: Union[Response, WebSocket]
+        self, request: Request | WebSocket, response: Response | WebSocket
     ) -> Context:  # pragma: no cover
         raise ValueError("`get_context` is not used by FastAPI GraphQL Router")
 
     async def get_root_value(
-        self, request: Union[Request, WebSocket]
-    ) -> Optional[RootValue]:  # pragma: no cover
+        self, request: Request | WebSocket
+    ) -> RootValue | None:  # pragma: no cover
         raise ValueError("`get_root_value` is not used by FastAPI GraphQL Router")
 
     async def get_sub_response(self, request: Request) -> Response:
@@ -279,7 +276,7 @@ class GraphQLRouter(
 
     def create_response(
         self,
-        response_data: Union[GraphQLHTTPResponse, list[GraphQLHTTPResponse]],
+        response_data: GraphQLHTTPResponse | list[GraphQLHTTPResponse],
         sub_response: Response,
     ) -> Response:
         response = Response(
@@ -309,18 +306,18 @@ class GraphQLRouter(
         )
 
     def is_websocket_request(
-        self, request: Union[Request, WebSocket]
+        self, request: Request | WebSocket
     ) -> TypeGuard[WebSocket]:
         return request.scope["type"] == "websocket"
 
-    async def pick_websocket_subprotocol(self, request: WebSocket) -> Optional[str]:
+    async def pick_websocket_subprotocol(self, request: WebSocket) -> str | None:
         protocols = request["subprotocols"]
         intersection = set(protocols) & set(self.protocols)
         sorted_intersection = sorted(intersection, key=protocols.index)
         return next(iter(sorted_intersection), None)
 
     async def create_websocket_response(
-        self, request: WebSocket, subprotocol: Optional[str]
+        self, request: WebSocket, subprotocol: str | None
     ) -> WebSocket:
         await request.accept(subprotocol=subprotocol)
         return request

strawberry/federation/argument.py

@@ -1,16 +1,15 @@
 from collections.abc import Iterable
-from typing import Optional
 
 from strawberry.types.arguments import StrawberryArgumentAnnotation
 
 
 def argument(
-    description: Optional[str] = None,
-    name: Optional[str] = None,
-    deprecation_reason: Optional[str] = None,
+    description: str | None = None,
+    name: str | None = None,
+    deprecation_reason: str | None = None,
     directives: Iterable[object] = (),
     inaccessible: bool = False,
-    tags: Optional[Iterable[str]] = (),
+    tags: Iterable[str] | None = (),
 ) -> StrawberryArgumentAnnotation:
     from strawberry.federation.schema_directives import Inaccessible, Tag