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

strawberry/chalice/views.py

@@ -1,56 +1,21 @@
 from __future__ import annotations
 
 import warnings
-from typing import TYPE_CHECKING, Any, Optional, Union, cast
+from typing import TYPE_CHECKING
 
 from chalice.app import Request, Response
-from strawberry.http.exceptions import HTTPException
-from strawberry.http.sync_base_view import SyncBaseHTTPView, SyncHTTPRequestAdapter
+from lia import ChaliceHTTPRequestAdapter, HTTPException
+
+from strawberry.http.sync_base_view import SyncBaseHTTPView
 from strawberry.http.temporal_response import TemporalResponse
 from strawberry.http.typevars import Context, RootValue
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping
-
     from strawberry.http import GraphQLHTTPResponse
     from strawberry.http.ides import GraphQL_IDE
-    from strawberry.http.types import HTTPMethod, QueryParams
     from strawberry.schema import BaseSchema
 
 
-class ChaliceHTTPRequestAdapter(SyncHTTPRequestAdapter):
-    def __init__(self, request: Request) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        return self.request.query_params or {}
-
-    @property
-    def body(self) -> Union[str, bytes]:
-        return self.request.raw_body
-
-    @property
-    def method(self) -> HTTPMethod:
-        return cast("HTTPMethod", self.request.method.upper())
-
-    @property
-    def headers(self) -> Mapping[str, str]:
-        return self.request.headers
-
-    @property
-    def post_data(self) -> Mapping[str, Union[str, bytes]]:
-        raise NotImplementedError
-
-    @property
-    def files(self) -> Mapping[str, Any]:
-        raise NotImplementedError
-
-    @property
-    def content_type(self) -> Optional[str]:
-        return self.request.headers.get("Content-Type", None)
-
-
 class GraphQLView(
     SyncBaseHTTPView[Request, Response, TemporalResponse, Context, RootValue]
 ):
@@ -60,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
@@ -76,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:
@@ -88,33 +53,13 @@ class GraphQLView(
     def get_sub_response(self, request: Request) -> TemporalResponse:
         return TemporalResponse()
 
-    @staticmethod
-    def error_response(
-        message: str,
-        error_code: str,
-        http_status_code: int,
-        headers: Optional[dict[str, str | list[str]]] = None,
-    ) -> Response:
-        """A wrapper for error responses.
-
-        Args:
-            message: The error message.
-            error_code: The error code.
-            http_status_code: The HTTP status code.
-            headers: The headers to include in the response.
-
-        Returns:
-            An errors response.
-        """
-        body = {"Code": error_code, "Message": message}
-
-        return Response(body=body, status_code=http_status_code, headers=headers)
-
     def get_context(self, request: Request, response: TemporalResponse) -> Context:
         return {"request": request, "response": response}  # type: ignore
 
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: TemporalResponse
+        self,
+        response_data: GraphQLHTTPResponse | list[GraphQLHTTPResponse],
+        sub_response: TemporalResponse,
     ) -> Response:
         status_code = 200
 
@@ -134,20 +79,9 @@ class GraphQLView(
         try:
             return self.run(request=request)
         except HTTPException as e:
-            error_code_map = {
-                400: "BadRequestError",
-                401: "UnauthorizedError",
-                403: "ForbiddenError",
-                404: "NotFoundError",
-                409: "ConflictError",
-                429: "TooManyRequestsError",
-                500: "ChaliceViewError",
-            }
-
-            return self.error_response(
-                error_code=error_code_map.get(e.status_code, "ChaliceViewError"),
-                message=e.reason,
-                http_status_code=e.status_code,
+            return Response(
+                body=e.reason,
+                status_code=e.status_code,
             )
 
 

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,34 +5,27 @@ 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, AsyncHTTPRequestAdapter
-from strawberry.http.exceptions import HTTPException
-from strawberry.http.sync_base_view import SyncBaseHTTPView, SyncHTTPRequestAdapter
+from strawberry.http.async_base_view import AsyncBaseHTTPView
+from strawberry.http.sync_base_view import SyncBaseHTTPView
 from strawberry.http.temporal_response import TemporalResponse
-from strawberry.http.types import FormData
 from strawberry.http.typevars import Context, RootValue
 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
@@ -84,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
@@ -130,9 +123,31 @@ 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
+    def url(self) -> str:
+        scheme = self.request.consumer.scope["scheme"]
+        host = self.headers.get("host", "localhost")
+        path = self.request.consumer.scope["path"]
+        query_string = self.request.consumer.scope["query_string"]
+        url = f"{scheme}://{host}{path}"
+        if query_string:
+            url += f"?{query_string.decode()}"
+        return url
+
+    @property
+    def cookies(self) -> Mapping[str, str]:
+        cookie_header = self.headers.get("cookie", "")
+        cookies = {}
+        if cookie_header:
+            for cookie in cookie_header.split(";"):
+                if "=" in cookie:
+                    key, value = cookie.split("=", 1)
+                    cookies[key.strip()] = value.strip()
+        return cookies
+
 
 class ChannelsRequestAdapter(BaseChannelsRequestAdapter, AsyncHTTPRequestAdapter):
     async def get_body(self) -> bytes:
@@ -148,23 +163,26 @@ class SyncChannelsRequestAdapter(BaseChannelsRequestAdapter, SyncHTTPRequestAdap
         return self.request.body
 
     @property
-    def post_data(self) -> Mapping[str, Union[str, bytes]]:
-        return self.request.form_data["form"]
+    def post_data(self) -> Mapping[str, str | bytes]:
+        return self.request.form_data.form
 
     @property
     def files(self) -> Mapping[str, Any]:
-        return self.request.form_data["files"]
+        return self.request.form_data.files
+
+    def get_form_data(self) -> FormData:
+        return self.request.form_data
 
 
 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,
@@ -186,7 +204,9 @@ class BaseGraphQLHTTPConsumer(ChannelsConsumer, AsyncHttpConsumer):
         super().__init__(**kwargs)
 
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: TemporalResponse
+        self,
+        response_data: GraphQLHTTPResponse | list[GraphQLHTTPResponse],
+        sub_response: TemporalResponse,
     ) -> ChannelsResponse:
         return ChannelsResponse(
             content=json.dumps(response_data).encode(),
@@ -227,7 +247,7 @@ class GraphQLHTTPConsumer(
     BaseGraphQLHTTPConsumer,
     AsyncBaseHTTPView[
         ChannelsRequest,
-        Union[ChannelsResponse, MultipartChannelsResponse],
+        ChannelsResponse | MultipartChannelsResponse,
         TemporalResponse,
         ChannelsRequest,
         TemporalResponse,
@@ -259,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(
@@ -302,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
 
@@ -333,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(
@@ -361,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)
 

strawberry/channels/handlers/ws_handler.py

@@ -5,11 +5,9 @@ import datetime
 import json
 from typing import (
     TYPE_CHECKING,
-    Optional,
     TypedDict,
-    Union,
+    TypeGuard,
 )
-from typing_extensions import TypeGuard
 
 from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncWebSocketAdapter
 from strawberry.http.exceptions import NonJsonMessageReceived, NonTextMessageReceived
@@ -62,7 +60,7 @@ class ChannelsWebSocketAdapter(AsyncWebSocketAdapter):
 
 
 class MessageQueueData(TypedDict):
-    message: Union[str, None]
+    message: str | None
     disconnected: bool
 
 
@@ -102,19 +100,18 @@ class GraphQLWSConsumer(
     ```
     """
 
-    websocket_adapter_class = ChannelsWebSocketAdapter
+    websocket_adapter_class = ChannelsWebSocketAdapter  # type: ignore
 
     def __init__(
         self,
         schema: BaseSchema,
         keep_alive: bool = False,
         keep_alive_interval: float = 1,
-        debug: bool = False,
         subscription_protocols: Sequence[str] = (
             GRAPHQL_TRANSPORT_WS_PROTOCOL,
             GRAPHQL_WS_PROTOCOL,
         ),
-        connection_init_wait_timeout: Optional[datetime.timedelta] = None,
+        connection_init_wait_timeout: datetime.timedelta | None = None,
     ) -> None:
         if connection_init_wait_timeout is None:
             connection_init_wait_timeout = datetime.timedelta(minutes=1)
@@ -122,10 +119,9 @@ class GraphQLWSConsumer(
         self.schema = schema
         self.keep_alive = keep_alive
         self.keep_alive_interval = keep_alive_interval
-        self.debug = debug
         self.protocols = subscription_protocols
         self.message_queue: asyncio.Queue[MessageQueueData] = asyncio.Queue()
-        self.run_task: Optional[asyncio.Task] = None
+        self.run_task: asyncio.Task | None = None
 
         super().__init__()
 
@@ -133,7 +129,7 @@ class GraphQLWSConsumer(
         self.run_task = asyncio.create_task(self.run(self))
 
     async def receive(
-        self, text_data: Optional[str] = None, bytes_data: Optional[bytes] = None
+        self, text_data: str | None = None, bytes_data: bytes | None = None
     ) -> None:
         if text_data:
             self.message_queue.put_nowait({"message": text_data, "disconnected": False})
@@ -145,7 +141,7 @@ class GraphQLWSConsumer(
         assert self.run_task
         await self.run_task
 
-    async def get_root_value(self, request: GraphQLWSConsumer) -> Optional[RootValue]:
+    async def get_root_value(self, request: GraphQLWSConsumer) -> RootValue | None:
         return None
 
     async def get_context(
@@ -164,7 +160,9 @@ class GraphQLWSConsumer(
         raise NotImplementedError
 
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: GraphQLWSConsumer
+        self,
+        response_data: GraphQLHTTPResponse | list[GraphQLHTTPResponse],
+        sub_response: GraphQLWSConsumer,
     ) -> GraphQLWSConsumer:
         raise NotImplementedError
 
@@ -178,14 +176,14 @@ class GraphQLWSConsumer(
 
     async def pick_websocket_subprotocol(
         self, request: GraphQLWSConsumer
-    ) -> Optional[str]:
+    ) -> str | None:
         protocols = request.scope["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: GraphQLWSConsumer, subprotocol: Optional[str]
+        self, request: GraphQLWSConsumer, subprotocol: str | None
     ) -> GraphQLWSConsumer:
         await request.accept(subprotocol=subprotocol)
         return request

strawberry/channels/router.py

@@ -7,11 +7,10 @@ on preferences and client support. Then it hands off to the appropriate consumer
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
-
-from django.urls import re_path
+from typing import TYPE_CHECKING
 
 from channels.routing import ProtocolTypeRouter, URLRouter
+from django.urls import re_path
 
 from .handlers.http_handler import GraphQLHTTPConsumer
 from .handlers.ws_handler import GraphQLWSConsumer
@@ -47,7 +46,7 @@ class GraphQLProtocolTypeRouter(ProtocolTypeRouter):
     def __init__(
         self,
         schema: BaseSchema,
-        django_application: Optional[str] = None,
+        django_application: str | None = None,
         url_pattern: str = "^graphql",
     ) -> None:
         http_urls = [re_path(url_pattern, GraphQLHTTPConsumer.as_asgi(schema=schema))]

strawberry/channels/testing.py

@@ -4,13 +4,11 @@ import uuid
 from typing import (
     TYPE_CHECKING,
     Any,
-    Optional,
-    Union,
 )
 
+from channels.testing.websocket import WebsocketCommunicator
 from graphql import GraphQLError, GraphQLFormattedError
 
-from channels.testing.websocket import WebsocketCommunicator
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
 from strawberry.subscriptions.protocols.graphql_transport_ws import (
     types as transport_ws_types,
@@ -53,7 +51,7 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
         self,
         application: ASGIApplication,
         path: str,
-        headers: Optional[list[tuple[bytes, bytes]]] = None,
+        headers: list[tuple[bytes, bytes]] | None = None,
         protocol: str = GRAPHQL_TRANSPORT_WS_PROTOCOL,
         connection_params: dict | None = None,
         **kwargs: Any,
@@ -83,9 +81,9 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
 
     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.disconnect()
 
@@ -114,8 +112,8 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
     # get transformed into `FormattedExecutionResult` on the wire, but we attempt
     # to do a limited representation of them here, to make testing simpler.
     async def subscribe(
-        self, query: str, variables: Optional[dict] = None
-    ) -> Union[ExecutionResult, AsyncIterator[ExecutionResult]]:
+        self, query: str, variables: dict | None = None
+    ) -> ExecutionResult | AsyncIterator[ExecutionResult]:
         id_ = uuid.uuid4().hex
 
         if self.protocol == GRAPHQL_TRANSPORT_WS_PROTOCOL:

strawberry/cli/__init__.py

@@ -1,15 +1,16 @@
 try:
     from .app import app
-    from .commands.codegen import codegen as codegen  # noqa: PLC0414
-    from .commands.export_schema import export_schema as export_schema  # noqa: PLC0414
+    from .commands.codegen import codegen as codegen
+    from .commands.dev import dev as dev
+    from .commands.export_schema import export_schema as export_schema
     from .commands.locate_definition import (
-        locate_definition as locate_definition,  # noqa: PLC0414
+        locate_definition as locate_definition,
     )
     from .commands.schema_codegen import (
-        schema_codegen as schema_codegen,  # noqa: PLC0414
+        schema_codegen as schema_codegen,
     )
-    from .commands.server import server as server  # noqa: PLC0414
-    from .commands.upgrade import upgrade as upgrade  # noqa: PLC0414
+    from .commands.server import server as server
+    from .commands.upgrade import upgrade as upgrade
 
     def run() -> None:
         app()

strawberry/cli/commands/codegen.py

@@ -4,7 +4,7 @@ import functools
 import importlib
 import inspect
 from pathlib import Path  # noqa: TC003
-from typing import Optional, Union, cast
+from typing import cast
 
 import rich
 import typer
@@ -22,9 +22,9 @@ def _is_codegen_plugin(obj: object) -> bool:
     )
 
 
-def _import_plugin(plugin: str) -> Optional[type[QueryCodegenPlugin]]:
+def _import_plugin(plugin: str) -> type[QueryCodegenPlugin] | None:
     module_name = plugin
-    symbol_name: Optional[str] = None
+    symbol_name: str | None = None
 
     if ":" in plugin:
         module_name, symbol_name = plugin.split(":", 1)
@@ -61,7 +61,7 @@ def _import_plugin(plugin: str) -> Optional[type[QueryCodegenPlugin]]:
 @functools.lru_cache
 def _load_plugin(
     plugin_path: str,
-) -> type[Union[QueryCodegenPlugin, ConsolePlugin]]:
+) -> type[QueryCodegenPlugin | ConsolePlugin]:
     # try to import plugin_name from current folder
     # then try to import from strawberry.codegen.plugins
 
@@ -79,7 +79,7 @@ def _load_plugin(
 
 def _load_plugins(
     plugin_ids: list[str], query: Path
-) -> list[Union[QueryCodegenPlugin, ConsolePlugin]]:
+) -> list[QueryCodegenPlugin | ConsolePlugin]:
     plugins = []
     for ptype_id in plugin_ids:
         ptype = _load_plugin(ptype_id)
@@ -91,7 +91,7 @@ def _load_plugins(
 
 @app.command(help="Generate code from a query")
 def codegen(
-    query: Optional[list[Path]] = typer.Argument(
+    query: list[Path] | None = typer.Argument(
         default=None, exists=True, dir_okay=False
     ),
     schema: str = typer.Option(..., help="Python path to the schema file"),
@@ -120,7 +120,7 @@ def codegen(
         "-p",
         "--plugins",
     ),
-    cli_plugin: Optional[str] = None,
+    cli_plugin: str | None = None,
 ) -> None:
     if not query:
         return