strawberry-graphql 0.243.1__tar.gz → 0.244.1__tar.gz

{strawberry_graphql-0.243.1 → strawberry_graphql-0.244.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.243.1
+Version: 0.244.1
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT

{strawberry_graphql-0.243.1 → strawberry_graphql-0.244.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.243.1"
+version = "0.244.1"
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "MIT"

{strawberry_graphql-0.243.1 → strawberry_graphql-0.244.1}/strawberry/aiohttp/views.py

@@ -4,6 +4,7 @@ import asyncio
 import warnings
 from datetime import timedelta
 from io import BytesIO
+from json.decoder import JSONDecodeError
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -16,15 +17,16 @@ from typing import (
     Union,
     cast,
 )
+from typing_extensions import TypeGuard
 
-from aiohttp import web
+from aiohttp import http, web
 from aiohttp.multipart import BodyPartReader
-from strawberry.aiohttp.handlers import (
-    GraphQLTransportWSHandler,
-    GraphQLWSHandler,
+from strawberry.http.async_base_view import (
+    AsyncBaseHTTPView,
+    AsyncHTTPRequestAdapter,
+    AsyncWebSocketAdapter,
 )
-from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncHTTPRequestAdapter
-from strawberry.http.exceptions import HTTPException
+from strawberry.http.exceptions import HTTPException, NonJsonMessageReceived
 from strawberry.http.types import FormData, HTTPMethod, QueryParams
 from strawberry.http.typevars import (
     Context,
@@ -79,11 +81,36 @@ class AioHTTPRequestAdapter(AsyncHTTPRequestAdapter):
         return self.headers.get("content-type")
 
 
+class AioHTTPWebSocketAdapter(AsyncWebSocketAdapter):
+    def __init__(self, request: web.Request, ws: web.WebSocketResponse) -> None:
+        self.request = request
+        self.ws = ws
+
+    async def iter_json(self) -> AsyncGenerator[Dict[str, object], None]:
+        async for ws_message in self.ws:
+            if ws_message.type == http.WSMsgType.TEXT:
+                try:
+                    yield ws_message.json()
+                except JSONDecodeError:
+                    raise NonJsonMessageReceived()
+
+            elif ws_message.type == http.WSMsgType.BINARY:
+                raise NonJsonMessageReceived()
+
+    async def send_json(self, message: Mapping[str, object]) -> None:
+        await self.ws.send_json(message)
+
+    async def close(self, code: int, reason: str) -> None:
+        await self.ws.close(code=code, message=reason.encode())
+
+
 class GraphQLView(
     AsyncBaseHTTPView[
         web.Request,
         Union[web.Response, web.StreamResponse],
         web.Response,
+        web.Request,
+        web.WebSocketResponse,
         Context,
         RootValue,
     ]
@@ -92,10 +119,9 @@ class GraphQLView(
     # bare handler function.
     _is_coroutine = asyncio.coroutines._is_coroutine  # type: ignore[attr-defined]
 
-    graphql_transport_ws_handler_class = GraphQLTransportWSHandler
-    graphql_ws_handler_class = GraphQLWSHandler
     allow_queries_via_get = True
     request_adapter_class = AioHTTPRequestAdapter
+    websocket_adapter_class = AioHTTPWebSocketAdapter
 
     def __init__(
         self,
@@ -138,48 +164,36 @@ class GraphQLView(
     async def get_sub_response(self, request: web.Request) -> web.Response:
         return web.Response()
 
-    async def __call__(self, request: web.Request) -> web.StreamResponse:
+    def is_websocket_request(self, request: web.Request) -> TypeGuard[web.Request]:
         ws = web.WebSocketResponse(protocols=self.subscription_protocols)
-        ws_test = ws.can_prepare(request)
-
-        if not ws_test.ok:
-            try:
-                return await self.run(request=request)
-            except HTTPException as e:
-                return web.Response(
-                    body=e.reason,
-                    status=e.status_code,
-                )
-
-        if ws_test.protocol == GRAPHQL_TRANSPORT_WS_PROTOCOL:
-            return await self.graphql_transport_ws_handler_class(
-                schema=self.schema,
-                debug=self.debug,
-                connection_init_wait_timeout=self.connection_init_wait_timeout,
-                get_context=self.get_context,  # type: ignore
-                get_root_value=self.get_root_value,
-                request=request,
-            ).handle()
-        elif ws_test.protocol == GRAPHQL_WS_PROTOCOL:
-            return await self.graphql_ws_handler_class(
-                schema=self.schema,
-                debug=self.debug,
-                keep_alive=self.keep_alive,
-                keep_alive_interval=self.keep_alive_interval,
-                get_context=self.get_context,
-                get_root_value=self.get_root_value,
-                request=request,
-            ).handle()
-        else:
-            await ws.prepare(request)
-            await ws.close(code=4406, message=b"Subprotocol not acceptable")
-            return ws
+        return ws.can_prepare(request).ok
+
+    async def pick_websocket_subprotocol(self, request: web.Request) -> Optional[str]:
+        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]
+    ) -> web.WebSocketResponse:
+        protocols = [subprotocol] if subprotocol else []
+        ws = web.WebSocketResponse(protocols=protocols)
+        await ws.prepare(request)
+        return ws
+
+    async def __call__(self, request: web.Request) -> web.StreamResponse:
+        try:
+            return await self.run(request=request)
+        except HTTPException as e:
+            return web.Response(
+                body=e.reason,
+                status=e.status_code,
+            )
 
     async def get_root_value(self, request: web.Request) -> Optional[RootValue]:
         return None
 
     async def get_context(
-        self, request: web.Request, response: web.Response
+        self, request: web.Request, response: Union[web.Response, web.WebSocketResponse]
     ) -> Context:
         return {"request": request, "response": response}  # type: ignore
 

{strawberry_graphql-0.243.1 → strawberry_graphql-0.244.1}/strawberry/asgi/__init__.py

@@ -2,9 +2,11 @@ from __future__ import annotations
 
 import warnings
 from datetime import timedelta
+from json import JSONDecodeError
 from typing import (
     TYPE_CHECKING,
     Any,
+    AsyncGenerator,
     AsyncIterator,
     Callable,
     Dict,
@@ -14,6 +16,7 @@ from typing import (
     Union,
     cast,
 )
+from typing_extensions import TypeGuard
 
 from starlette import status
 from starlette.requests import Request
@@ -23,14 +26,14 @@ from starlette.responses import (
     Response,
     StreamingResponse,
 )
-from starlette.websockets import WebSocket
+from starlette.websockets import WebSocket, WebSocketDisconnect, WebSocketState
 
-from strawberry.asgi.handlers import (
-    GraphQLTransportWSHandler,
-    GraphQLWSHandler,
+from strawberry.http.async_base_view import (
+    AsyncBaseHTTPView,
+    AsyncHTTPRequestAdapter,
+    AsyncWebSocketAdapter,
 )
-from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncHTTPRequestAdapter
-from strawberry.http.exceptions import HTTPException
+from strawberry.http.exceptions import HTTPException, NonJsonMessageReceived
 from strawberry.http.types import FormData, HTTPMethod, QueryParams
 from strawberry.http.typevars import (
     Context,
@@ -78,19 +81,41 @@ class ASGIRequestAdapter(AsyncHTTPRequestAdapter):
         )
 
 
+class ASGIWebSocketAdapter(AsyncWebSocketAdapter):
+    def __init__(self, request: WebSocket, response: WebSocket) -> None:
+        self.ws = response
+
+    async def iter_json(self) -> AsyncGenerator[Dict[str, object], None]:
+        try:
+            try:
+                while self.ws.application_state != WebSocketState.DISCONNECTED:
+                    yield await self.ws.receive_json()
+            except (KeyError, JSONDecodeError):
+                raise NonJsonMessageReceived()
+        except WebSocketDisconnect:  # pragma: no cover
+            pass
+
+    async def send_json(self, message: Mapping[str, object]) -> None:
+        await self.ws.send_json(message)
+
+    async def close(self, code: int, reason: str) -> None:
+        await self.ws.close(code=code, reason=reason)
+
+
 class GraphQL(
     AsyncBaseHTTPView[
-        Union[Request, WebSocket],
+        Request,
         Response,
         Response,
+        WebSocket,
+        WebSocket,
         Context,
         RootValue,
     ]
 ):
-    graphql_transport_ws_handler_class = GraphQLTransportWSHandler
-    graphql_ws_handler_class = GraphQLWSHandler
     allow_queries_via_get = True
-    request_adapter_class = ASGIRequestAdapter  # pyright: ignore
+    request_adapter_class = ASGIRequestAdapter
+    websocket_adapter_class = ASGIWebSocketAdapter
 
     def __init__(
         self,
@@ -129,51 +154,25 @@ class GraphQL(
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
         if scope["type"] == "http":
-            return await self.handle_http(scope, receive, send)
+            http_request = Request(scope=scope, receive=receive)
 
-        elif scope["type"] == "websocket":
-            ws = WebSocket(scope, receive=receive, send=send)
-            preferred_protocol = self.pick_preferred_protocol(ws)
-
-            if preferred_protocol == GRAPHQL_TRANSPORT_WS_PROTOCOL:
-                await self.graphql_transport_ws_handler_class(
-                    schema=self.schema,
-                    debug=self.debug,
-                    connection_init_wait_timeout=self.connection_init_wait_timeout,
-                    get_context=self.get_context,
-                    get_root_value=self.get_root_value,
-                    ws=ws,
-                ).handle()
-
-            elif preferred_protocol == GRAPHQL_WS_PROTOCOL:
-                await self.graphql_ws_handler_class(
-                    schema=self.schema,
-                    debug=self.debug,
-                    keep_alive=self.keep_alive,
-                    keep_alive_interval=self.keep_alive_interval,
-                    get_context=self.get_context,
-                    get_root_value=self.get_root_value,
-                    ws=ws,
-                ).handle()
-
-            else:
-                # Subprotocol not acceptable
-                await ws.close(code=4406)
+            try:
+                response = await self.run(http_request)
+            except HTTPException as e:
+                response = PlainTextResponse(e.reason, status_code=e.status_code)
 
+            await response(scope, receive, send)
+        elif scope["type"] == "websocket":
+            ws_request = WebSocket(scope, receive=receive, send=send)
+            await self.run(ws_request)
         else:  # pragma: no cover
             raise ValueError("Unknown scope type: {!r}".format(scope["type"]))
 
-    def pick_preferred_protocol(self, ws: WebSocket) -> Optional[str]:
-        protocols = ws["subprotocols"]
-        intersection = set(protocols) & set(self.protocols)
-        sorted_intersection = sorted(intersection, key=protocols.index)
-        return next(iter(sorted_intersection), None)
-
     async def get_root_value(self, request: Union[Request, WebSocket]) -> Optional[Any]:
         return None
 
     async def get_context(
-        self, request: Union[Request, WebSocket], response: Response
+        self, request: Union[Request, WebSocket], response: Union[Response, WebSocket]
     ) -> Context:
         return {"request": request, "response": response}  # type: ignore
 
@@ -187,21 +186,6 @@ class GraphQL(
 
         return sub_response
 
-    async def handle_http(
-        self,
-        scope: Scope,
-        receive: Receive,
-        send: Send,
-    ) -> None:
-        request = Request(scope=scope, receive=receive)
-
-        try:
-            response = await self.run(request)
-        except HTTPException as e:
-            response = PlainTextResponse(e.reason, status_code=e.status_code)  # pyright: ignore
-
-        await response(scope, receive, send)
-
     async def render_graphql_ide(self, request: Union[Request, WebSocket]) -> Response:
         return HTMLResponse(self.graphql_ide_html)
 
@@ -239,3 +223,20 @@ class GraphQL(
                 **headers,
             },
         )
+
+    def is_websocket_request(
+        self, request: Union[Request, WebSocket]
+    ) -> TypeGuard[WebSocket]:
+        return request.scope["type"] == "websocket"
+
+    async def pick_websocket_subprotocol(self, request: WebSocket) -> Optional[str]:
+        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]
+    ) -> WebSocket:
+        await request.accept(subprotocol=subprotocol)
+        return request

{strawberry_graphql-0.243.1 → strawberry_graphql-0.244.1}/strawberry/channels/__init__.py

@@ -1,6 +1,4 @@
-from .handlers.base import ChannelsConsumer, ChannelsWSConsumer
-from .handlers.graphql_transport_ws_handler import GraphQLTransportWSHandler
-from .handlers.graphql_ws_handler import GraphQLWSHandler
+from .handlers.base import ChannelsConsumer
 from .handlers.http_handler import (
     ChannelsRequest,
     GraphQLHTTPConsumer,
@@ -12,10 +10,7 @@ from .router import GraphQLProtocolTypeRouter
 __all__ = [
     "ChannelsConsumer",
     "ChannelsRequest",
-    "ChannelsWSConsumer",
     "GraphQLProtocolTypeRouter",
-    "GraphQLWSHandler",
-    "GraphQLTransportWSHandler",
     "GraphQLHTTPConsumer",
     "GraphQLWSConsumer",
     "SyncGraphQLHTTPConsumer",

{strawberry_graphql-0.243.1 → strawberry_graphql-0.244.1}/strawberry/channels/handlers/base.py

@@ -16,7 +16,7 @@ from typing_extensions import Literal, Protocol, TypedDict
 from weakref import WeakSet
 
 from channels.consumer import AsyncConsumer
-from channels.generic.websocket import AsyncJsonWebsocketConsumer
+from channels.generic.websocket import AsyncWebsocketConsumer
 
 
 class ChannelsMessage(TypedDict, total=False):
@@ -210,7 +210,7 @@ class ChannelsConsumer(AsyncConsumer):
                 return
 
 
-class ChannelsWSConsumer(ChannelsConsumer, AsyncJsonWebsocketConsumer):
+class ChannelsWSConsumer(ChannelsConsumer, AsyncWebsocketConsumer):
     """Base channels websocket async consumer."""
 
 

{strawberry_graphql-0.243.1 → strawberry_graphql-0.244.1}/strawberry/channels/handlers/http_handler.py

@@ -15,7 +15,7 @@ from typing import (
     Optional,
     Union,
 )
-from typing_extensions import assert_never
+from typing_extensions import TypeGuard, assert_never
 from urllib.parse import parse_qs
 
 from django.conf import settings
@@ -233,6 +233,8 @@ class GraphQLHTTPConsumer(
         ChannelsRequest,
         Union[ChannelsResponse, MultipartChannelsResponse],
         TemporalResponse,
+        ChannelsRequest,
+        TemporalResponse,
         Context,
         RootValue,
     ],
@@ -298,6 +300,21 @@ class GraphQLHTTPConsumer(
             content=self.graphql_ide_html.encode(), content_type="text/html"
         )
 
+    def is_websocket_request(
+        self, request: ChannelsRequest
+    ) -> TypeGuard[ChannelsRequest]:
+        return False
+
+    async def pick_websocket_subprotocol(
+        self, request: ChannelsRequest
+    ) -> Optional[str]:
+        return None
+
+    async def create_websocket_response(
+        self, request: ChannelsRequest, subprotocol: Optional[str]
+    ) -> TemporalResponse:
+        raise NotImplementedError
+
 
 class SyncGraphQLHTTPConsumer(
     BaseGraphQLHTTPConsumer,

strawberry_graphql-0.244.1/strawberry/channels/handlers/ws_handler.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import asyncio
+import datetime
+import json
+from typing import (
+    TYPE_CHECKING,
+    AsyncGenerator,
+    Dict,
+    Mapping,
+    Optional,
+    Tuple,
+    TypedDict,
+    Union,
+)
+from typing_extensions import TypeGuard
+
+from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncWebSocketAdapter
+from strawberry.http.exceptions import NonJsonMessageReceived
+from strawberry.http.typevars import Context, RootValue
+from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
+
+from .base import ChannelsWSConsumer
+
+if TYPE_CHECKING:
+    from strawberry.http import GraphQLHTTPResponse
+    from strawberry.schema import BaseSchema
+
+
+class ChannelsWebSocketAdapter(AsyncWebSocketAdapter):
+    def __init__(self, request: GraphQLWSConsumer, response: GraphQLWSConsumer) -> None:
+        self.ws_consumer = response
+
+    async def iter_json(self) -> AsyncGenerator[Dict[str, object], None]:
+        while True:
+            message = await self.ws_consumer.message_queue.get()
+
+            if message["disconnected"]:
+                break
+
+            if message["message"] is None:
+                raise NonJsonMessageReceived()
+
+            try:
+                yield json.loads(message["message"])
+            except json.JSONDecodeError:
+                raise NonJsonMessageReceived()
+
+    async def send_json(self, message: Mapping[str, object]) -> None:
+        serialized_message = json.dumps(message)
+        await self.ws_consumer.send(serialized_message)
+
+    async def close(self, code: int, reason: str) -> None:
+        await self.ws_consumer.close(code=code, reason=reason)
+
+
+class MessageQueueData(TypedDict):
+    message: Union[str, None]
+    disconnected: bool
+
+
+class GraphQLWSConsumer(
+    ChannelsWSConsumer,
+    AsyncBaseHTTPView[
+        "GraphQLWSConsumer",
+        "GraphQLWSConsumer",
+        "GraphQLWSConsumer",
+        "GraphQLWSConsumer",
+        "GraphQLWSConsumer",
+        Context,
+        RootValue,
+    ],
+):
+    """A channels websocket consumer for GraphQL.
+
+    This handles the connections, then hands off to the appropriate
+    handler based on the subprotocol.
+
+    To use this, place it in your ProtocolTypeRouter for your channels project, e.g:
+
+    ```
+    from strawberry.channels import GraphQLHttpRouter
+    from channels.routing import ProtocolTypeRouter
+    from django.core.asgi import get_asgi_application
+
+    application = ProtocolTypeRouter({
+        "http": URLRouter([
+            re_path("^graphql", GraphQLHTTPRouter(schema=schema)),
+            re_path("^", get_asgi_application()),
+        ]),
+        "websocket": URLRouter([
+            re_path("^ws/graphql", GraphQLWebSocketRouter(schema=schema)),
+        ]),
+    })
+    ```
+    """
+
+    websocket_adapter_class = ChannelsWebSocketAdapter
+
+    def __init__(
+        self,
+        schema: BaseSchema,
+        keep_alive: bool = False,
+        keep_alive_interval: float = 1,
+        debug: bool = False,
+        subscription_protocols: Tuple[str, str] = (
+            GRAPHQL_TRANSPORT_WS_PROTOCOL,
+            GRAPHQL_WS_PROTOCOL,
+        ),
+        connection_init_wait_timeout: Optional[datetime.timedelta] = None,
+    ) -> None:
+        if connection_init_wait_timeout is None:
+            connection_init_wait_timeout = datetime.timedelta(minutes=1)
+        self.connection_init_wait_timeout = connection_init_wait_timeout
+        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
+
+        super().__init__()
+
+    async def connect(self) -> None:
+        self.run_task = asyncio.create_task(self.run(self))
+
+    async def receive(
+        self, text_data: Optional[str] = None, bytes_data: Optional[bytes] = None
+    ) -> None:
+        if text_data:
+            self.message_queue.put_nowait({"message": text_data, "disconnected": False})
+        else:
+            self.message_queue.put_nowait({"message": None, "disconnected": False})
+
+    async def disconnect(self, code: int) -> None:
+        self.message_queue.put_nowait({"message": None, "disconnected": True})
+        assert self.run_task
+        await self.run_task
+
+    async def get_root_value(self, request: GraphQLWSConsumer) -> Optional[RootValue]:
+        return None
+
+    async def get_context(
+        self, request: GraphQLWSConsumer, response: GraphQLWSConsumer
+    ) -> Context:
+        return {
+            "request": request,
+            "ws": request,
+        }  # type: ignore
+
+    @property
+    def allow_queries_via_get(self) -> bool:
+        return False
+
+    async def get_sub_response(self, request: GraphQLWSConsumer) -> GraphQLWSConsumer:
+        raise NotImplementedError
+
+    def create_response(
+        self, response_data: GraphQLHTTPResponse, sub_response: GraphQLWSConsumer
+    ) -> GraphQLWSConsumer:
+        raise NotImplementedError
+
+    async def render_graphql_ide(self, request: GraphQLWSConsumer) -> GraphQLWSConsumer:
+        raise NotImplementedError
+
+    def is_websocket_request(
+        self, request: GraphQLWSConsumer
+    ) -> TypeGuard[GraphQLWSConsumer]:
+        return True
+
+    async def pick_websocket_subprotocol(
+        self, request: GraphQLWSConsumer
+    ) -> Optional[str]:
+        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]
+    ) -> GraphQLWSConsumer:
+        await request.accept(subprotocol=subprotocol)
+        return request
+
+
+__all__ = ["GraphQLWSConsumer"]

{strawberry_graphql-0.243.1 → strawberry_graphql-0.244.1}/strawberry/codegen/query_codegen.py

@@ -645,20 +645,22 @@ class QueryCodegen:
     ) -> Tuple[
         Union[type, StrawberryType], Optional[Callable[[GraphQLType], GraphQLType]]
     ]:
-        wrapper = None
+        wrapper: Optional[Callable[[GraphQLType], GraphQLType]] = None
 
         if isinstance(type_, StrawberryOptional):
-            type_, wrapper = self._unwrap_type(type_.of_type)
+            type_, previous_wrapper = self._unwrap_type(type_.of_type)
             wrapper = (
                 GraphQLOptional
-                if wrapper is None
-                else lambda t: GraphQLOptional(wrapper(t))  # type: ignore[misc]
+                if previous_wrapper is None
+                else lambda t: GraphQLOptional(previous_wrapper(t))  # type: ignore[misc]
             )
 
         elif isinstance(type_, StrawberryList):
-            type_, wrapper = self._unwrap_type(type_.of_type)
+            type_, previous_wrapper = self._unwrap_type(type_.of_type)
             wrapper = (
-                GraphQLList if wrapper is None else lambda t: GraphQLList(wrapper(t))
+                GraphQLList
+                if previous_wrapper is None
+                else lambda t: GraphQLList(previous_wrapper(t))
             )
 
         elif isinstance(type_, LazyType):