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

strawberry/aiohttp/test/client.py

@@ -1,27 +1,20 @@
 from __future__ import annotations
 
 import warnings
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Optional,
-)
+from typing import Any
 
 from strawberry.test.client import BaseGraphQLTestClient, Response
 
-if TYPE_CHECKING:
-    from collections.abc import Mapping
-
 
 class GraphQLTestClient(BaseGraphQLTestClient):
     async def query(
         self,
         query: str,
-        variables: Optional[dict[str, Mapping]] = None,
-        headers: Optional[dict[str, object]] = None,
-        asserts_errors: Optional[bool] = None,
-        files: Optional[dict[str, object]] = None,
-        assert_no_errors: Optional[bool] = True,
+        variables: dict[str, Any] | None = None,
+        headers: dict[str, object] | None = None,
+        asserts_errors: bool | None = None,
+        files: dict[str, object] | None = None,
+        assert_no_errors: bool | None = True,
     ) -> Response:
         body = self._build_body(query, variables, files)
 
@@ -54,8 +47,8 @@ class GraphQLTestClient(BaseGraphQLTestClient):
     async def request(
         self,
         body: dict[str, object],
-        headers: Optional[dict[str, object]] = None,
-        files: Optional[dict[str, object]] = None,
+        headers: dict[str, object] | None = None,
+        files: dict[str, object] | None = None,
     ) -> Any:
         return await self._client.post(
             self.url,

strawberry/aiohttp/views.py

@@ -6,15 +6,12 @@ from datetime import timedelta
 from json.decoder import JSONDecodeError
 from typing import (
     TYPE_CHECKING,
-    Callable,
-    Optional,
-    Union,
+    TypeGuard,
 )
-from typing_extensions import TypeGuard
 
+from aiohttp import ClientConnectionResetError, http, web
 from lia import AiohttpHTTPRequestAdapter, HTTPException
 
-from aiohttp import ClientConnectionResetError, http, web
 from strawberry.http.async_base_view import (
     AsyncBaseHTTPView,
     AsyncWebSocketAdapter,
@@ -31,7 +28,7 @@ from strawberry.http.typevars import (
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncGenerator, Mapping, Sequence
+    from collections.abc import AsyncGenerator, Callable, Mapping, Sequence
 
     from strawberry.http import GraphQLHTTPResponse
     from strawberry.http.ides import GraphQL_IDE
@@ -73,7 +70,7 @@ class AiohttpWebSocketAdapter(AsyncWebSocketAdapter):
 class GraphQLView(
     AsyncBaseHTTPView[
         web.Request,
-        Union[web.Response, web.StreamResponse],
+        web.Response | web.StreamResponse,
         web.Response,
         web.Request,
         web.WebSocketResponse,
@@ -87,13 +84,13 @@ class GraphQLView(
 
     allow_queries_via_get = True
     request_adapter_class = AiohttpHTTPRequestAdapter
-    websocket_adapter_class = AiohttpWebSocketAdapter
+    websocket_adapter_class = AiohttpWebSocketAdapter  # type: ignore
 
     def __init__(
         self,
         schema: BaseSchema,
-        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 = True,
         keep_alive_interval: float = 1,
@@ -132,12 +129,12 @@ class GraphQLView(
         ws = web.WebSocketResponse(protocols=self.subscription_protocols)
         return ws.can_prepare(request).ok
 
-    async def pick_websocket_subprotocol(self, request: web.Request) -> Optional[str]:
+    async def pick_websocket_subprotocol(self, request: web.Request) -> str | None:
         ws = web.WebSocketResponse(protocols=self.subscription_protocols)
         return ws.can_prepare(request).protocol
 
     async def create_websocket_response(
-        self, request: web.Request, subprotocol: Optional[str]
+        self, request: web.Request, subprotocol: str | None
     ) -> web.WebSocketResponse:
         protocols = [subprotocol] if subprotocol else []
         ws = web.WebSocketResponse(protocols=protocols)
@@ -153,17 +150,17 @@ class GraphQLView(
                 status=e.status_code,
             )
 
-    async def get_root_value(self, request: web.Request) -> Optional[RootValue]:
+    async def get_root_value(self, request: web.Request) -> RootValue | None:
         return None
 
     async def get_context(
-        self, request: web.Request, response: Union[web.Response, web.WebSocketResponse]
+        self, request: web.Request, response: web.Response | web.WebSocketResponse
     ) -> Context:
         return {"request": request, "response": response}  # type: ignore
 
     def create_response(
         self,
-        response_data: Union[GraphQLHTTPResponse, list[GraphQLHTTPResponse]],
+        response_data: GraphQLHTTPResponse | list[GraphQLHTTPResponse],
         sub_response: web.Response,
     ) -> web.Response:
         sub_response.text = self.encode_json(response_data)

strawberry/annotation.py

@@ -5,17 +5,19 @@ import typing
 import warnings
 from collections import abc
 from enum import Enum
+from types import UnionType
 from typing import (
     TYPE_CHECKING,
     Annotated,
     Any,
     ForwardRef,
-    Optional,
     TypeVar,
     Union,
     cast,
+    get_args,
+    get_origin,
 )
-from typing_extensions import Self, get_args, get_origin
+from typing_extensions import Self
 
 from strawberry.streamable import StrawberryStreamable
 from strawberry.types.base import (
@@ -58,14 +60,14 @@ class StrawberryAnnotation:
 
     def __init__(
         self,
-        annotation: Union[object, str],
+        annotation: object | str,
         *,
-        namespace: Optional[dict[str, Any]] = None,
+        namespace: dict[str, Any] | None = None,
     ) -> None:
         self.raw_annotation = annotation
         self.namespace = namespace
 
-        self.__resolve_cache__: Optional[Union[StrawberryType, type]] = None
+        self.__resolve_cache__: StrawberryType | type | None = None
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, StrawberryAnnotation):
@@ -78,8 +80,8 @@ class StrawberryAnnotation:
 
     @staticmethod
     def from_annotation(
-        annotation: object, namespace: Optional[dict[str, Any]] = None
-    ) -> Optional[StrawberryAnnotation]:
+        annotation: object, namespace: dict[str, Any] | None = None
+    ) -> StrawberryAnnotation | None:
         if annotation is None:
             return None
 
@@ -88,7 +90,7 @@ class StrawberryAnnotation:
         return annotation
 
     @property
-    def annotation(self) -> Union[object, str]:
+    def annotation(self) -> object | str:
         """Return evaluated type on success or fallback to raw (string) annotation."""
         try:
             return self.evaluate()
@@ -98,7 +100,7 @@ class StrawberryAnnotation:
             return self.raw_annotation
 
     @annotation.setter
-    def annotation(self, value: Union[object, str]) -> None:
+    def annotation(self, value: object | str) -> None:
         self.raw_annotation = value
 
         self.__resolve_cache__ = None
@@ -128,8 +130,8 @@ class StrawberryAnnotation:
     def resolve(
         self,
         *,
-        type_definition: Optional[StrawberryObjectDefinition] = None,
-    ) -> Union[StrawberryType, type]:
+        type_definition: StrawberryObjectDefinition | None = None,
+    ) -> StrawberryType | type:
         """Return resolved (transformed) annotation."""
         if (resolved := self.__resolve_cache__) is None:
             resolved = self._resolve()
@@ -158,11 +160,11 @@ class StrawberryAnnotation:
 
         return resolved
 
-    def _resolve(self) -> Union[StrawberryType, type]:
+    def _resolve(self) -> StrawberryType | type:
         evaled_type = cast("Any", self.evaluate())
         return self._resolve_evaled_type(evaled_type)
 
-    def _resolve_evaled_type(self, evaled_type: Any) -> Union[StrawberryType, type]:
+    def _resolve_evaled_type(self, evaled_type: Any) -> StrawberryType | type:
         if is_private(evaled_type):
             return evaled_type
 
@@ -244,7 +246,7 @@ class StrawberryAnnotation:
         # passed as we can safely use `Union` for both optional types
         # (e.g. `Optional[str]`) and optional unions (e.g.
         # `Optional[Union[TypeA, TypeB]]`)
-        child_type = Union[non_optional_types]  # type: ignore
+        child_type = Union[non_optional_types]  # type: ignore  # noqa: UP007
 
         of_type = StrawberryAnnotation(
             annotation=child_type,
@@ -321,7 +323,7 @@ class StrawberryAnnotation:
         return issubclass(annotation, Enum)
 
     @classmethod
-    def _is_type_generic(cls, type_: Union[StrawberryType, type]) -> bool:
+    def _is_type_generic(cls, type_: StrawberryType | type) -> bool:
         """Returns True if `resolver_type` is generic else False."""
         from strawberry.types.base import StrawberryType
 
@@ -413,16 +415,10 @@ class StrawberryAnnotation:
         """Returns True if annotation is a Union."""
         # this check is needed because unions declared with the new syntax `A | B`
         # don't have a `__origin__` property on them, but they are instances of
-        # `UnionType`, which is only available in Python 3.10+
-        if sys.version_info >= (3, 10):
-            from types import UnionType
-
-            if isinstance(annotation, UnionType):
-                return True
+        if isinstance(annotation, UnionType):
+            return True
 
         # unions declared as Union[A, B] fall through to this check
-        # even on python 3.10+
-
         annotation_origin = getattr(annotation, "__origin__", None)
 
         if annotation_origin is typing.Union:

strawberry/asgi/__init__.py

@@ -5,11 +5,8 @@ from datetime import timedelta
 from json import JSONDecodeError
 from typing import (
     TYPE_CHECKING,
-    Callable,
-    Optional,
-    Union,
+    TypeGuard,
 )
-from typing_extensions import TypeGuard
 
 from lia import HTTPException, StarletteRequestAdapter
 from starlette import status
@@ -38,7 +35,13 @@ from strawberry.http.typevars import (
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncGenerator, AsyncIterator, Mapping, Sequence
+    from collections.abc import (
+        AsyncGenerator,
+        AsyncIterator,
+        Callable,
+        Mapping,
+        Sequence,
+    )
 
     from starlette.types import Receive, Scope, Send
 
@@ -93,13 +96,13 @@ class GraphQL(
 ):
     allow_queries_via_get = True
     request_adapter_class = StarletteRequestAdapter
-    websocket_adapter_class = ASGIWebSocketAdapter
+    websocket_adapter_class = ASGIWebSocketAdapter  # type: ignore
 
     def __init__(
         self,
         schema: BaseSchema,
-        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,
@@ -144,19 +147,17 @@ class GraphQL(
         else:  # pragma: no cover
             raise ValueError("Unknown scope type: {!r}".format(scope["type"]))
 
-    async def get_root_value(
-        self, request: Union[Request, WebSocket]
-    ) -> Optional[RootValue]:
+    async def get_root_value(self, request: Request | WebSocket) -> RootValue | None:
         return None
 
     async def get_context(
-        self, request: Union[Request, WebSocket], response: Union[Response, WebSocket]
+        self, request: Request | WebSocket, response: Response | WebSocket
     ) -> Context:
         return {"request": request, "response": response}  # type: ignore
 
     async def get_sub_response(
         self,
-        request: Union[Request, WebSocket],
+        request: Request | WebSocket,
     ) -> Response:
         sub_response = Response()
         sub_response.status_code = None  # type: ignore
@@ -169,7 +170,7 @@ class GraphQL(
 
     def create_response(
         self,
-        response_data: Union[GraphQLHTTPResponse, list[GraphQLHTTPResponse]],
+        response_data: GraphQLHTTPResponse | list[GraphQLHTTPResponse],
         sub_response: Response,
     ) -> Response:
         response = Response(
@@ -205,18 +206,18 @@ class GraphQL(
         )
 
     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/asgi/test/client.py

@@ -1,21 +1,21 @@
 from __future__ import annotations
 
 import json
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from strawberry.test import BaseGraphQLTestClient
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
-    from typing_extensions import Literal
+    from typing import Literal
 
 
 class GraphQLTestClient(BaseGraphQLTestClient):
     def _build_body(
         self,
         query: str,
-        variables: Optional[dict[str, Mapping]] = None,
-        files: Optional[dict[str, object]] = None,
+        variables: dict[str, Mapping] | None = None,
+        files: dict[str, object] | None = None,
     ) -> dict[str, object]:
         body: dict[str, object] = {"query": query}
 
@@ -36,8 +36,8 @@ class GraphQLTestClient(BaseGraphQLTestClient):
     def request(
         self,
         body: dict[str, object],
-        headers: Optional[dict[str, object]] = None,
-        files: Optional[dict[str, object]] = None,
+        headers: dict[str, object] | None = None,
+        files: dict[str, object] | None = None,
     ) -> Any:
         return self._client.post(
             self.url,

strawberry/chalice/views.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
 import warnings
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING
 
+from chalice.app import Request, Response
 from lia import ChaliceHTTPRequestAdapter, HTTPException
 
-from chalice.app import Request, Response
 from strawberry.http.sync_base_view import SyncBaseHTTPView
 from strawberry.http.temporal_response import TemporalResponse
 from strawberry.http.typevars import Context, RootValue
@@ -25,8 +25,8 @@ class GraphQLView(
     def __init__(
         self,
         schema: BaseSchema,
-        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,
     ) -> None:
         self.allow_queries_via_get = allow_queries_via_get
@@ -41,7 +41,7 @@ class GraphQLView(
         else:
             self.graphql_ide = graphql_ide
 
-    def get_root_value(self, request: Request) -> Optional[RootValue]:
+    def get_root_value(self, request: Request) -> RootValue | None:
         return None
 
     def render_graphql_ide(self, request: Request) -> Response:
@@ -58,7 +58,7 @@ class GraphQLView(
 
     def create_response(
         self,
-        response_data: Union[GraphQLHTTPResponse, list[GraphQLHTTPResponse]],
+        response_data: GraphQLHTTPResponse | list[GraphQLHTTPResponse],
         sub_response: TemporalResponse,
     ) -> Response:
         status_code = 200

strawberry/channels/handlers/base.py

@@ -2,13 +2,12 @@ import asyncio
 import contextlib
 import warnings
 from collections import defaultdict
-from collections.abc import AsyncGenerator, Awaitable, Sequence
+from collections.abc import AsyncGenerator, Awaitable, Callable, Sequence
 from typing import (
     Any,
-    Callable,
-    Optional,
+    Literal,
 )
-from typing_extensions import Literal, Protocol, TypedDict
+from typing_extensions import Protocol, TypedDict
 from weakref import WeakSet
 
 from channels.consumer import AsyncConsumer
@@ -54,7 +53,7 @@ class ChannelsConsumer(AsyncConsumer):
     """Base channels async consumer."""
 
     channel_name: str
-    channel_layer: Optional[ChannelsLayer]
+    channel_layer: ChannelsLayer | None
     channel_receive: Callable[[], Awaitable[dict]]
 
     def __init__(self, *args: str, **kwargs: Any) -> None:
@@ -80,7 +79,7 @@ class ChannelsConsumer(AsyncConsumer):
         self,
         type: str,
         *,
-        timeout: Optional[float] = None,
+        timeout: float | None = None,
         groups: Sequence[str] = (),
     ) -> AsyncGenerator[Any, None]:
         """Listen for messages sent to this consumer.
@@ -139,7 +138,7 @@ class ChannelsConsumer(AsyncConsumer):
         self,
         type: str,
         *,
-        timeout: Optional[float] = None,
+        timeout: float | None = None,
         groups: Sequence[str] = (),
     ) -> AsyncGenerator[Any, None]:
         """Listen for messages sent to this consumer.
@@ -188,7 +187,7 @@ class ChannelsConsumer(AsyncConsumer):
                     await self.channel_layer.group_discard(group, self.channel_name)
 
     async def _listen_to_channel_generator(
-        self, queue: asyncio.Queue, timeout: Optional[float]
+        self, queue: asyncio.Queue, timeout: float | None
     ) -> AsyncGenerator[Any, None]:
         """Generator for listen_to_channel method.
 

strawberry/channels/handlers/http_handler.py

@@ -5,17 +5,17 @@ import json
 import warnings
 from functools import cached_property
 from io import BytesIO
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union
-from typing_extensions import TypeGuard, assert_never
+from typing import TYPE_CHECKING, Any, TypeGuard
+from typing_extensions import assert_never
 from urllib.parse import parse_qs
 
+from channels.db import database_sync_to_async
+from channels.generic.http import AsyncHttpConsumer
 from django.conf import settings
 from django.core.files import uploadhandler
 from django.http.multipartparser import MultiPartParser
 from lia import AsyncHTTPRequestAdapter, FormData, HTTPException, SyncHTTPRequestAdapter
 
-from channels.db import database_sync_to_async
-from channels.generic.http import AsyncHttpConsumer
 from strawberry.http.async_base_view import AsyncBaseHTTPView
 from strawberry.http.sync_base_view import SyncBaseHTTPView
 from strawberry.http.temporal_response import TemporalResponse
@@ -25,7 +25,7 @@ from strawberry.types.unset import UNSET
 from .base import ChannelsConsumer
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncGenerator, Mapping
+    from collections.abc import AsyncGenerator, Callable, Mapping
 
     from strawberry.http import GraphQLHTTPResponse
     from strawberry.http.ides import GraphQL_IDE
@@ -77,7 +77,7 @@ class ChannelsRequest:
         return self.consumer.scope["method"].upper()
 
     @property
-    def content_type(self) -> Optional[str]:
+    def content_type(self) -> str | None:
         return self.headers.get("content-type", None)
 
     @cached_property
@@ -123,7 +123,7 @@ class BaseChannelsRequestAdapter:
         return self.request.headers
 
     @property
-    def content_type(self) -> Optional[str]:
+    def content_type(self) -> str | None:
         return self.request.content_type
 
     @property
@@ -163,7 +163,7 @@ class SyncChannelsRequestAdapter(BaseChannelsRequestAdapter, SyncHTTPRequestAdap
         return self.request.body
 
     @property
-    def post_data(self) -> Mapping[str, Union[str, bytes]]:
+    def post_data(self) -> Mapping[str, str | bytes]:
         return self.request.form_data.form
 
     @property
@@ -176,13 +176,13 @@ class SyncChannelsRequestAdapter(BaseChannelsRequestAdapter, SyncHTTPRequestAdap
 
 class BaseGraphQLHTTPConsumer(ChannelsConsumer, AsyncHttpConsumer):
     graphql_ide_html: str
-    graphql_ide: Optional[GraphQL_IDE] = "graphiql"
+    graphql_ide: GraphQL_IDE | None = "graphiql"
 
     def __init__(
         self,
         schema: BaseSchema,
-        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,
         multipart_uploads_enabled: bool = False,
         **kwargs: Any,
@@ -205,7 +205,7 @@ class BaseGraphQLHTTPConsumer(ChannelsConsumer, AsyncHttpConsumer):
 
     def create_response(
         self,
-        response_data: Union[GraphQLHTTPResponse, list[GraphQLHTTPResponse]],
+        response_data: GraphQLHTTPResponse | list[GraphQLHTTPResponse],
         sub_response: TemporalResponse,
     ) -> ChannelsResponse:
         return ChannelsResponse(
@@ -247,7 +247,7 @@ class GraphQLHTTPConsumer(
     BaseGraphQLHTTPConsumer,
     AsyncBaseHTTPView[
         ChannelsRequest,
-        Union[ChannelsResponse, MultipartChannelsResponse],
+        ChannelsResponse | MultipartChannelsResponse,
         TemporalResponse,
         ChannelsRequest,
         TemporalResponse,
@@ -279,7 +279,7 @@ class GraphQLHTTPConsumer(
     allow_queries_via_get: bool = True
     request_adapter_class = ChannelsRequestAdapter
 
-    async def get_root_value(self, request: ChannelsRequest) -> Optional[RootValue]:
+    async def get_root_value(self, request: ChannelsRequest) -> RootValue | None:
         return None  # pragma: no cover
 
     async def get_context(
@@ -322,13 +322,11 @@ class GraphQLHTTPConsumer(
     ) -> TypeGuard[ChannelsRequest]:
         return False
 
-    async def pick_websocket_subprotocol(
-        self, request: ChannelsRequest
-    ) -> Optional[str]:
+    async def pick_websocket_subprotocol(self, request: ChannelsRequest) -> str | None:
         return None
 
     async def create_websocket_response(
-        self, request: ChannelsRequest, subprotocol: Optional[str]
+        self, request: ChannelsRequest, subprotocol: str | None
     ) -> TemporalResponse:
         raise NotImplementedError
 
@@ -353,7 +351,7 @@ class SyncGraphQLHTTPConsumer(
     allow_queries_via_get: bool = True
     request_adapter_class = SyncChannelsRequestAdapter
 
-    def get_root_value(self, request: ChannelsRequest) -> Optional[RootValue]:
+    def get_root_value(self, request: ChannelsRequest) -> RootValue | None:
         return None  # pragma: no cover
 
     def get_context(
@@ -381,7 +379,7 @@ class SyncGraphQLHTTPConsumer(
         self,
         request: ChannelsRequest,
         context: Context = UNSET,
-        root_value: Optional[RootValue] = UNSET,
+        root_value: RootValue | None = UNSET,
     ) -> ChannelsResponse | MultipartChannelsResponse:
         return super().run(request, context, root_value)