strawberry-graphql 0.238.1__tar.gz → 0.239.1__tar.gz

{strawberry_graphql-0.238.1 → strawberry_graphql-0.239.1}/PKG-INFO

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

{strawberry_graphql-0.238.1 → strawberry_graphql-0.239.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.238.1"
+version = "0.239.1"
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "MIT"
@@ -173,6 +173,12 @@ filterwarnings = [
     # ignoring the text instead of the whole warning because we'd
     # get an error when django is not installed
     "ignore:The default value of USE_TZ",
+    "ignore::DeprecationWarning:pydantic_openapi_schema.*",
+    "ignore::DeprecationWarning:graphql.*",
+    "ignore::DeprecationWarning:websockets.*",
+    "ignore::DeprecationWarning:pydantic.*",
+    "ignore::UserWarning:pydantic.*",
+    "ignore::DeprecationWarning:pkg_resources.*",
 ]
 
 [tool.autopub]

{strawberry_graphql-0.238.1 → strawberry_graphql-0.239.1}/strawberry/aiohttp/views.py

@@ -7,10 +7,13 @@ from io import BytesIO
 from typing import (
     TYPE_CHECKING,
     Any,
+    AsyncGenerator,
+    Callable,
     Dict,
     Iterable,
     Mapping,
     Optional,
+    Union,
     cast,
 )
 
@@ -73,11 +76,17 @@ class AioHTTPRequestAdapter(AsyncHTTPRequestAdapter):
 
     @property
     def content_type(self) -> Optional[str]:
-        return self.request.content_type
+        return self.headers.get("content-type")
 
 
 class GraphQLView(
-    AsyncBaseHTTPView[web.Request, web.Response, web.Response, Context, RootValue]
+    AsyncBaseHTTPView[
+        web.Request,
+        Union[web.Response, web.StreamResponse],
+        web.Response,
+        Context,
+        RootValue,
+    ]
 ):
     # Mark the view as coroutine so that AIOHTTP does not confuse it with a deprecated
     # bare handler function.
@@ -180,5 +189,29 @@ class GraphQLView(
 
         return sub_response
 
+    async def create_streaming_response(
+        self,
+        request: web.Request,
+        stream: Callable[[], AsyncGenerator[str, None]],
+        sub_response: web.Response,
+        headers: Dict[str, str],
+    ) -> web.StreamResponse:
+        response = web.StreamResponse(
+            status=sub_response.status,
+            headers={
+                **sub_response.headers,
+                **headers,
+            },
+        )
+
+        await response.prepare(request)
+
+        async for data in stream():
+            await response.write(data.encode())
+
+        await response.write_eof()
+
+        return response
+
 
 __all__ = ["GraphQLView"]

{strawberry_graphql-0.238.1 → strawberry_graphql-0.239.1}/strawberry/asgi/__init__.py

@@ -5,6 +5,9 @@ from datetime import timedelta
 from typing import (
     TYPE_CHECKING,
     Any,
+    AsyncIterator,
+    Callable,
+    Dict,
     Mapping,
     Optional,
     Sequence,
@@ -14,7 +17,12 @@ from typing import (
 
 from starlette import status
 from starlette.requests import Request
-from starlette.responses import HTMLResponse, PlainTextResponse, Response
+from starlette.responses import (
+    HTMLResponse,
+    PlainTextResponse,
+    Response,
+    StreamingResponse,
+)
 from starlette.websockets import WebSocket
 
 from strawberry.asgi.handlers import (
@@ -213,3 +221,19 @@ class GraphQL(
             response.status_code = sub_response.status_code
 
         return response
+
+    async def create_streaming_response(
+        self,
+        request: Request | WebSocket,
+        stream: Callable[[], AsyncIterator[str]],
+        sub_response: Response,
+        headers: Dict[str, str],
+    ) -> Response:
+        return StreamingResponse(
+            stream(),
+            status_code=sub_response.status_code or status.HTTP_200_OK,
+            headers={
+                **sub_response.headers,
+                **headers,
+            },
+        )

{strawberry_graphql-0.238.1 → strawberry_graphql-0.239.1}/strawberry/channels/handlers/http_handler.py

@@ -1,8 +1,3 @@
-"""GraphQLHTTPHandler.
-
-A consumer to provide a graphql endpoint, and optionally graphiql.
-"""
-
 from __future__ import annotations
 
 import dataclasses
@@ -10,7 +5,17 @@ import json
 import warnings
 from functools import cached_property
 from io import BytesIO
-from typing import TYPE_CHECKING, Any, Dict, Mapping, Optional, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncGenerator,
+    Callable,
+    Dict,
+    Mapping,
+    Optional,
+    Union,
+)
+from typing_extensions import assert_never
 from urllib.parse import parse_qs
 
 from django.conf import settings
@@ -44,6 +49,14 @@ class ChannelsResponse:
     headers: Dict[bytes, bytes] = dataclasses.field(default_factory=dict)
 
 
+@dataclasses.dataclass
+class MultipartChannelsResponse:
+    stream: Callable[[], AsyncGenerator[str, None]]
+    status: int = 200
+    content_type: str = "multipart/mixed;boundary=graphql;subscriptionSpec=1.0"
+    headers: Dict[bytes, bytes] = dataclasses.field(default_factory=dict)
+
+
 @dataclasses.dataclass
 class ChannelsRequest:
     consumer: ChannelsConsumer
@@ -186,16 +199,28 @@ class BaseGraphQLHTTPConsumer(ChannelsConsumer, AsyncHttpConsumer):
     async def handle(self, body: bytes) -> None:
         request = ChannelsRequest(consumer=self, body=body)
         try:
-            response: ChannelsResponse = await self.run(request)
+            response = await self.run(request)
 
             if b"Content-Type" not in response.headers:
                 response.headers[b"Content-Type"] = response.content_type.encode()
 
-            await self.send_response(
-                response.status,
-                response.content,
-                headers=response.headers,
-            )
+            if isinstance(response, MultipartChannelsResponse):
+                response.headers[b"Transfer-Encoding"] = b"chunked"
+                await self.send_headers(headers=response.headers)
+
+                async for chunk in response.stream():
+                    await self.send_body(chunk.encode("utf-8"), more_body=True)
+
+                await self.send_body(b"", more_body=False)
+
+            elif isinstance(response, ChannelsResponse):
+                await self.send_response(
+                    response.status,
+                    response.content,
+                    headers=response.headers,
+                )
+            else:
+                assert_never(response)
         except HTTPException as e:
             await self.send_response(e.status_code, e.reason.encode())
 
@@ -204,7 +229,7 @@ class GraphQLHTTPConsumer(
     BaseGraphQLHTTPConsumer,
     AsyncBaseHTTPView[
         ChannelsRequest,
-        ChannelsResponse,
+        Union[ChannelsResponse, MultipartChannelsResponse],
         TemporalResponse,
         Context,
         RootValue,
@@ -248,6 +273,24 @@ class GraphQLHTTPConsumer(
     async def get_sub_response(self, request: ChannelsRequest) -> TemporalResponse:
         return TemporalResponse()
 
+    async def create_streaming_response(
+        self,
+        request: ChannelsRequest,
+        stream: Callable[[], AsyncGenerator[str, None]],
+        sub_response: TemporalResponse,
+        headers: Dict[str, str],
+    ) -> MultipartChannelsResponse:
+        status = sub_response.status_code or 200
+
+        response_headers = {
+            k.encode(): v.encode() for k, v in sub_response.headers.items()
+        }
+        response_headers.update({k.encode(): v.encode() for k, v in headers.items()})
+
+        return MultipartChannelsResponse(
+            stream=stream, status=status, headers=response_headers
+        )
+
     async def render_graphql_ide(self, request: ChannelsRequest) -> ChannelsResponse:
         return ChannelsResponse(
             content=self.graphql_ide_html.encode(), content_type="text/html"
@@ -302,7 +345,7 @@ class SyncGraphQLHTTPConsumer(
         request: ChannelsRequest,
         context: Optional[Context] = UNSET,
         root_value: Optional[RootValue] = UNSET,
-    ) -> ChannelsResponse:
+    ) -> ChannelsResponse | MultipartChannelsResponse:
         return super().run(request, context, root_value)
 
 

{strawberry_graphql-0.238.1 → strawberry_graphql-0.239.1}/strawberry/django/views.py

@@ -5,7 +5,9 @@ import warnings
 from typing import (
     TYPE_CHECKING,
     Any,
+    AsyncIterator,
     Callable,
+    Dict,
     Mapping,
     Optional,
     Union,
@@ -14,8 +16,14 @@ from typing import (
 
 from asgiref.sync import markcoroutinefunction
 from django.core.serializers.json import DjangoJSONEncoder
-from django.http import HttpRequest, HttpResponseNotAllowed, JsonResponse
-from django.http.response import HttpResponse
+from django.http import (
+    HttpRequest,
+    HttpResponse,
+    HttpResponseNotAllowed,
+    JsonResponse,
+    StreamingHttpResponse,
+)
+from django.http.response import HttpResponseBase
 from django.template import RequestContext, Template
 from django.template.exceptions import TemplateDoesNotExist
 from django.template.loader import render_to_string
@@ -116,7 +124,7 @@ class AsyncDjangoHTTPRequestAdapter(AsyncHTTPRequestAdapter):
 
     @property
     def content_type(self) -> Optional[str]:
-        return self.request.content_type
+        return self.headers.get("Content-type")
 
     async def get_body(self) -> str:
         return self.request.body.decode()
@@ -159,8 +167,9 @@ class BaseView:
 
     def create_response(
         self, response_data: GraphQLHTTPResponse, sub_response: HttpResponse
-    ) -> HttpResponse:
+    ) -> HttpResponseBase:
         data = self.encode_json(response_data)
+
         response = HttpResponse(
             data,
             content_type="application/json",
@@ -177,6 +186,22 @@ class BaseView:
 
         return response
 
+    async def create_streaming_response(
+        self,
+        request: HttpRequest,
+        stream: Callable[[], AsyncIterator[Any]],
+        sub_response: TemporalHttpResponse,
+        headers: Dict[str, str],
+    ) -> HttpResponseBase:
+        return StreamingHttpResponse(
+            streaming_content=stream(),
+            status=sub_response.status_code,
+            headers={
+                **sub_response.headers,
+                **headers,
+            },
+        )
+
     def encode_json(self, response_data: GraphQLHTTPResponse) -> str:
         return json.dumps(response_data, cls=DjangoJSONEncoder)
 
@@ -184,7 +209,7 @@ class BaseView:
 class GraphQLView(
     BaseView,
     SyncBaseHTTPView[
-        HttpRequest, HttpResponse, TemporalHttpResponse, Context, RootValue
+        HttpRequest, HttpResponseBase, TemporalHttpResponse, Context, RootValue
     ],
     View,
 ):
@@ -207,7 +232,7 @@ class GraphQLView(
     @method_decorator(csrf_exempt)
     def dispatch(
         self, request: HttpRequest, *args: Any, **kwargs: Any
-    ) -> Union[HttpResponseNotAllowed, TemplateResponse, HttpResponse]:
+    ) -> Union[HttpResponseNotAllowed, TemplateResponse, HttpResponseBase]:
         try:
             return self.run(request=request)
         except HTTPException as e:
@@ -233,7 +258,7 @@ class GraphQLView(
 class AsyncGraphQLView(
     BaseView,
     AsyncBaseHTTPView[
-        HttpRequest, HttpResponse, TemporalHttpResponse, Context, RootValue
+        HttpRequest, HttpResponseBase, TemporalHttpResponse, Context, RootValue
     ],
     View,
 ):
@@ -266,7 +291,7 @@ class AsyncGraphQLView(
     @method_decorator(csrf_exempt)
     async def dispatch(  # pyright: ignore
         self, request: HttpRequest, *args: Any, **kwargs: Any
-    ) -> Union[HttpResponseNotAllowed, TemplateResponse, HttpResponse]:
+    ) -> Union[HttpResponseNotAllowed, TemplateResponse, HttpResponseBase]:
         try:
             return await self.run(request=request)
         except HTTPException as e:

{strawberry_graphql-0.238.1 → strawberry_graphql-0.239.1}/strawberry/fastapi/router.py

@@ -6,6 +6,7 @@ from inspect import signature
 from typing import (
     TYPE_CHECKING,
     Any,
+    AsyncIterator,
     Awaitable,
     Callable,
     Dict,
@@ -25,6 +26,7 @@ from starlette.responses import (
     JSONResponse,
     PlainTextResponse,
     Response,
+    StreamingResponse,
 )
 from starlette.websockets import WebSocket
 
@@ -330,5 +332,21 @@ class GraphQLRouter(
 
         return response
 
+    async def create_streaming_response(
+        self,
+        request: Request,
+        stream: Callable[[], AsyncIterator[str]],
+        sub_response: Response,
+        headers: Dict[str, str],
+    ) -> Response:
+        return StreamingResponse(
+            stream(),
+            status_code=sub_response.status_code or status.HTTP_200_OK,
+            headers={
+                **sub_response.headers,
+                **headers,
+            },
+        )
+
 
 __all__ = ["GraphQLRouter"]

{strawberry_graphql-0.238.1 → strawberry_graphql-0.239.1}/strawberry/flask/views.py

@@ -1,7 +1,14 @@
 from __future__ import annotations
 
 import warnings
-from typing import TYPE_CHECKING, Any, Mapping, Optional, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Mapping,
+    Optional,
+    Union,
+    cast,
+)
 
 from flask import Request, Response, render_template_string, request
 from flask.views import View

{strawberry_graphql-0.238.1 → strawberry_graphql-0.239.1}/strawberry/http/async_base_view.py

@@ -1,12 +1,17 @@
 import abc
+import asyncio
+import contextlib
 import json
 from typing import (
+    Any,
+    AsyncGenerator,
     Callable,
     Dict,
     Generic,
     List,
     Mapping,
     Optional,
+    Tuple,
     Union,
 )
 
@@ -15,15 +20,20 @@ from graphql import GraphQLError
 from strawberry import UNSET
 from strawberry.exceptions import MissingQueryError
 from strawberry.file_uploads.utils import replace_placeholders_with_files
-from strawberry.http import GraphQLHTTPResponse, GraphQLRequestData, process_result
+from strawberry.http import (
+    GraphQLHTTPResponse,
+    GraphQLRequestData,
+    process_result,
+)
 from strawberry.http.ides import GraphQL_IDE
 from strawberry.schema.base import BaseSchema
 from strawberry.schema.exceptions import InvalidOperationTypeError
-from strawberry.types import ExecutionResult
+from strawberry.types import ExecutionResult, SubscriptionExecutionResult
 from strawberry.types.graphql import OperationType
 
 from .base import BaseView
 from .exceptions import HTTPException
+from .parse_content_type import parse_content_type
 from .types import FormData, HTTPMethod, QueryParams
 from .typevars import Context, Request, Response, RootValue, SubResponse
 
@@ -82,9 +92,18 @@ class AsyncBaseHTTPView(
     @abc.abstractmethod
     async def render_graphql_ide(self, request: Request) -> Response: ...
 
+    async def create_streaming_response(
+        self,
+        request: Request,
+        stream: Callable[[], AsyncGenerator[str, None]],
+        sub_response: SubResponse,
+        headers: Dict[str, str],
+    ) -> Response:
+        raise ValueError("Multipart responses are not supported")
+
     async def execute_operation(
         self, request: Request, context: Context, root_value: Optional[RootValue]
-    ) -> ExecutionResult:
+    ) -> Union[ExecutionResult, SubscriptionExecutionResult]:
         request_adapter = self.request_adapter_class(request)
 
         try:
@@ -178,6 +197,19 @@ class AsyncBaseHTTPView(
         except MissingQueryError as e:
             raise HTTPException(400, "No GraphQL query found in the request") from e
 
+        if isinstance(result, SubscriptionExecutionResult):
+            stream = self._get_stream(request, result)
+
+            return await self.create_streaming_response(
+                request,
+                stream,
+                sub_response,
+                headers={
+                    "Transfer-Encoding": "chunked",
+                    "Content-Type": "multipart/mixed;boundary=graphql;subscriptionSpec=1.0,application/json",
+                },
+            )
+
         response_data = await self.process_result(request=request, result=result)
 
         if result.errors:
@@ -187,17 +219,107 @@ class AsyncBaseHTTPView(
             response_data=response_data, sub_response=sub_response
         )
 
+    def encode_multipart_data(self, data: Any, separator: str) -> str:
+        return "".join(
+            [
+                f"\r\n--{separator}\r\n",
+                "Content-Type: application/json\r\n\r\n",
+                self.encode_json(data),
+                "\n",
+            ]
+        )
+
+    def _stream_with_heartbeat(
+        self, stream: Callable[[], AsyncGenerator[str, None]]
+    ) -> Callable[[], AsyncGenerator[str, None]]:
+        """Adds a heartbeat to the stream, to prevent the connection from closing when there are no messages being sent."""
+        queue = asyncio.Queue[Tuple[bool, Any]](1)
+
+        cancelling = False
+
+        async def drain() -> None:
+            try:
+                async for item in stream():
+                    await queue.put((False, item))
+            except Exception as e:
+                if not cancelling:
+                    await queue.put((True, e))
+                else:
+                    raise
+
+        async def heartbeat() -> None:
+            while True:
+                await queue.put((False, self.encode_multipart_data({}, "graphql")))
+
+                await asyncio.sleep(5)
+
+        async def merged() -> AsyncGenerator[str, None]:
+            heartbeat_task = asyncio.create_task(heartbeat())
+            task = asyncio.create_task(drain())
+
+            async def cancel_tasks() -> None:
+                nonlocal cancelling
+                cancelling = True
+                task.cancel()
+
+                with contextlib.suppress(asyncio.CancelledError):
+                    await task
+
+                heartbeat_task.cancel()
+
+                with contextlib.suppress(asyncio.CancelledError):
+                    await heartbeat_task
+
+            try:
+                while not task.done():
+                    raised, data = await queue.get()
+
+                    if raised:
+                        await cancel_tasks()
+                        raise data
+
+                    yield data
+            finally:
+                await cancel_tasks()
+
+        return merged
+
+    def _get_stream(
+        self,
+        request: Request,
+        result: SubscriptionExecutionResult,
+        separator: str = "graphql",
+    ) -> Callable[[], AsyncGenerator[str, None]]:
+        async def stream() -> AsyncGenerator[str, None]:
+            async for value in result:
+                response = await self.process_result(request, value)
+                yield self.encode_multipart_data({"payload": response}, separator)
+
+            yield f"\r\n--{separator}--\r\n"
+
+        return self._stream_with_heartbeat(stream)
+
+    async def parse_multipart_subscriptions(
+        self, request: AsyncHTTPRequestAdapter
+    ) -> Dict[str, str]:
+        if request.method == "GET":
+            return self.parse_query_params(request.query_params)
+
+        return self.parse_json(await request.get_body())
+
     async def parse_http_body(
         self, request: AsyncHTTPRequestAdapter
     ) -> GraphQLRequestData:
-        content_type = request.content_type or ""
+        content_type, params = parse_content_type(request.content_type or "")
 
         if request.method == "GET":
             data = self.parse_query_params(request.query_params)
         elif "application/json" in content_type:
             data = self.parse_json(await request.get_body())
-        elif content_type.startswith("multipart/form-data"):
+        elif content_type == "multipart/form-data":
             data = await self.parse_multipart(request)
+        elif self._is_multipart_subscriptions(content_type, params):
+            data = await self.parse_multipart_subscriptions(request)
         else:
             raise HTTPException(400, "Unsupported content type")
 

{strawberry_graphql-0.238.1 → strawberry_graphql-0.239.1}/strawberry/http/base.py

@@ -69,5 +69,16 @@ class BaseView(Generic[Request]):
             graphql_ide=self.graphql_ide,
         )
 
+    def _is_multipart_subscriptions(
+        self, content_type: str, params: Dict[str, str]
+    ) -> bool:
+        if content_type != "multipart/mixed":
+            return False
+
+        if params.get("boundary") != "graphql":
+            return False
+
+        return params.get("subscriptionspec", "").startswith("1.0")
+
 
 __all__ = ["BaseView"]

strawberry_graphql-0.239.1/strawberry/http/parse_content_type.py

@@ -0,0 +1,16 @@
+from email.message import Message
+from typing import Dict, Tuple
+
+
+def parse_content_type(content_type: str) -> Tuple[str, Dict[str, str]]:
+    """Parse a content type header into a mime-type and a dictionary of parameters."""
+    email = Message()
+    email["content-type"] = content_type
+
+    params = email.get_params()
+
+    assert params
+
+    mime_type, _ = params.pop(0)
+
+    return mime_type, dict(params)

{strawberry_graphql-0.238.1 → strawberry_graphql-0.239.1}/strawberry/http/sync_base_view.py

@@ -16,7 +16,11 @@ from graphql import GraphQLError
 from strawberry import UNSET
 from strawberry.exceptions import MissingQueryError
 from strawberry.file_uploads.utils import replace_placeholders_with_files
-from strawberry.http import GraphQLHTTPResponse, GraphQLRequestData, process_result
+from strawberry.http import (
+    GraphQLHTTPResponse,
+    GraphQLRequestData,
+    process_result,
+)
 from strawberry.http.ides import GraphQL_IDE
 from strawberry.schema import BaseSchema
 from strawberry.schema.exceptions import InvalidOperationTypeError
@@ -25,6 +29,7 @@ from strawberry.types.graphql import OperationType
 
 from .base import BaseView
 from .exceptions import HTTPException
+from .parse_content_type import parse_content_type
 from .types import HTTPMethod, QueryParams
 from .typevars import Context, Request, Response, RootValue, SubResponse
 
@@ -131,14 +136,19 @@ class SyncBaseHTTPView(
             raise HTTPException(400, "File(s) missing in form data") from e
 
     def parse_http_body(self, request: SyncHTTPRequestAdapter) -> GraphQLRequestData:
-        content_type = request.content_type or ""
+        content_type, params = parse_content_type(request.content_type or "")
 
         if request.method == "GET":
             data = self.parse_query_params(request.query_params)
         elif "application/json" in content_type:
             data = self.parse_json(request.body)
-        elif content_type.startswith("multipart/form-data"):
+        # TODO: multipart via get?
+        elif content_type == "multipart/form-data":
             data = self.parse_multipart(request)
+        elif self._is_multipart_subscriptions(content_type, params):
+            raise HTTPException(
+                400, "Multipart subcriptions are not supported in sync mode"
+            )
         else:
             raise HTTPException(400, "Unsupported content type")