strawberry-graphql 0.269.0.dev1747164009__py3-none-any.whl → 0.270.1__py3-none-any.whl

strawberry/http/async_base_view.py

@@ -372,26 +372,71 @@ class AsyncBaseHTTPView(
         )
 
     def _stream_with_heartbeat(
-        self, stream: Callable[[], AsyncGenerator[str, None]]
+        self, stream: Callable[[], AsyncGenerator[str, None]], separator: str
     ) -> 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]] = asyncio.Queue(1)
-
+        """Add heartbeat messages to a GraphQL stream to prevent connection timeouts.
+
+        This method wraps an async stream generator with heartbeat functionality by:
+        1. Creating a queue to coordinate between data and heartbeat messages
+        2. Running two concurrent tasks: one for original stream data, one for heartbeats
+        3. Merging both message types into a single output stream
+
+        Messages in the queue are tuples of (raised, done, data) where:
+        - raised (bool): True if this contains an exception to be re-raised
+        - done (bool): True if this is the final signal indicating stream completion
+        - data: The actual message content to yield, or exception if raised=True
+               Note: data is always None when done=True and can be ignored
+
+        Note: This implementation addresses two critical concerns:
+
+        1. Race condition: There's a potential race between checking task.done() and
+           processing the final message. We solve this by having the drain task send
+           an explicit (False, True, None) completion signal as its final action.
+           Without this signal, we might exit before processing the final boundary.
+
+           Since the queue size is 1 and the drain task will only complete after
+           successfully queueing the done signal, task.done() guarantees the done
+           signal is either in the queue or has already been processed. This ensures
+           we never miss the final boundary.
+
+        2. Flow control: The queue has maxsize=1, which is essential because:
+           - It provides natural backpressure between producers and consumer
+           - Prevents heartbeat messages from accumulating when drain is active
+           - Ensures proper task coordination without complex synchronization
+           - Guarantees the done signal is queued before drain task completes
+
+        Heartbeats are sent every 5 seconds when the drain task isn't sending data.
+
+        Note: Due to the asynchronous nature of the heartbeat task, an extra heartbeat
+        message may be sent after the final stream boundary message. This is safe because
+        both the MIME specification (RFC 2046) and Apollo's GraphQL Multipart HTTP protocol
+        require clients to ignore any content after the final boundary marker. Additionally,
+        Apollo's protocol defines heartbeats as empty JSON objects that clients must
+        silently ignore.
+        """
+        queue: asyncio.Queue[tuple[bool, bool, Any]] = asyncio.Queue(
+            maxsize=1,  # Critical: maxsize=1 for flow control.
+        )
         cancelling = False
 
         async def drain() -> None:
             try:
                 async for item in stream():
-                    await queue.put((False, item))
+                    await queue.put((False, False, item))
             except Exception as e:
                 if not cancelling:
-                    await queue.put((True, e))
+                    await queue.put((True, False, e))
                 else:
                     raise
+            # Send completion signal to prevent race conditions. The queue.put()
+            # blocks until space is available (due to maxsize=1), guaranteeing that
+            # when task.done() is True, the final stream message has been dequeued.
+            await queue.put((False, True, None))  # Always use None with done=True
 
         async def heartbeat() -> None:
             while True:
-                await queue.put((False, self.encode_multipart_data({}, "graphql")))
+                item = self.encode_multipart_data({}, separator)
+                await queue.put((False, False, item))
 
                 await asyncio.sleep(5)
 
@@ -413,8 +458,19 @@ class AsyncBaseHTTPView(
                     await heartbeat_task
 
             try:
+                # When task.done() is True, the final stream message has been
+                # dequeued due to queue size 1 and the blocking nature of queue.put().
                 while not task.done():
-                    raised, data = await queue.get()
+                    raised, done, data = await queue.get()
+
+                    if done:
+                        # Received done signal (data is None), stream is complete.
+                        # Note that we may not get here because of the race between
+                        # task.done() and queue.get(), but that's OK because if
+                        # task.done() is True, the actual final message (including any
+                        # exception) has been consumed. The only intent here is to
+                        # ensure that data=None is not yielded.
+                        break
 
                     if raised:
                         await cancel_tasks()
@@ -439,7 +495,7 @@ class AsyncBaseHTTPView(
 
             yield f"\r\n--{separator}--\r\n"
 
-        return self._stream_with_heartbeat(stream)
+        return self._stream_with_heartbeat(stream, separator)
 
     async def parse_multipart_subscriptions(
         self, request: AsyncHTTPRequestAdapter

strawberry/quart/views.py

@@ -1,15 +1,29 @@
+import asyncio
 import warnings
-from collections.abc import AsyncGenerator, Mapping
-from typing import TYPE_CHECKING, Callable, ClassVar, Optional, cast
+from collections.abc import AsyncGenerator, Mapping, Sequence
+from datetime import timedelta
+from json.decoder import JSONDecodeError
+from typing import TYPE_CHECKING, Callable, ClassVar, Optional, Union, cast
 from typing_extensions import TypeGuard
 
-from quart import Request, Response, request
+from quart import Request, Response, Websocket, request, websocket
+from quart.ctx import has_websocket_context
 from quart.views import View
-from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncHTTPRequestAdapter
-from strawberry.http.exceptions import HTTPException
+from strawberry.http.async_base_view import (
+    AsyncBaseHTTPView,
+    AsyncHTTPRequestAdapter,
+    AsyncWebSocketAdapter,
+)
+from strawberry.http.exceptions import (
+    HTTPException,
+    NonJsonMessageReceived,
+    NonTextMessageReceived,
+    WebSocketDisconnected,
+)
 from strawberry.http.ides import GraphQL_IDE
 from strawberry.http.types import FormData, HTTPMethod, QueryParams
 from strawberry.http.typevars import Context, RootValue
+from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
 
 if TYPE_CHECKING:
     from quart.typing import ResponseReturnValue
@@ -46,15 +60,55 @@ class QuartHTTPRequestAdapter(AsyncHTTPRequestAdapter):
         return FormData(files=files, form=form)
 
 
+class QuartWebSocketAdapter(AsyncWebSocketAdapter):
+    def __init__(
+        self, view: AsyncBaseHTTPView, request: Websocket, response: Response
+    ) -> None:
+        super().__init__(view)
+        self.ws = request
+
+    async def iter_json(
+        self, *, ignore_parsing_errors: bool = False
+    ) -> AsyncGenerator[object, None]:
+        try:
+            while True:
+                # Raises asyncio.CancelledError when the connection is closed.
+                # https://quart.palletsprojects.com/en/latest/how_to_guides/websockets.html#detecting-disconnection
+                message = await self.ws.receive()
+
+                if not isinstance(message, str):
+                    raise NonTextMessageReceived
+
+                try:
+                    yield self.view.decode_json(message)
+                except JSONDecodeError as e:
+                    if not ignore_parsing_errors:
+                        raise NonJsonMessageReceived from e
+        except asyncio.CancelledError:
+            pass
+
+    async def send_json(self, message: Mapping[str, object]) -> None:
+        try:
+            # Raises asyncio.CancelledError when the connection is closed.
+            # https://quart.palletsprojects.com/en/latest/how_to_guides/websockets.html#detecting-disconnection
+            await self.ws.send(self.view.encode_json(message))
+        except asyncio.CancelledError as exc:
+            raise WebSocketDisconnected from exc
+
+    async def close(self, code: int, reason: str) -> None:
+        await self.ws.close(code, reason=reason)
+
+
 class GraphQLView(
     AsyncBaseHTTPView[
-        Request, Response, Response, Request, Response, Context, RootValue
+        Request, Response, Response, Websocket, Response, Context, RootValue
     ],
     View,
 ):
     methods: ClassVar[list[str]] = ["GET", "POST"]
     allow_queries_via_get: bool = True
     request_adapter_class = QuartHTTPRequestAdapter
+    websocket_adapter_class = QuartWebSocketAdapter
 
     def __init__(
         self,
@@ -62,10 +116,23 @@ class GraphQLView(
         graphiql: Optional[bool] = None,
         graphql_ide: Optional[GraphQL_IDE] = "graphiql",
         allow_queries_via_get: bool = True,
+        keep_alive: bool = True,
+        keep_alive_interval: float = 1,
+        debug: bool = False,
+        subscription_protocols: Sequence[str] = (
+            GRAPHQL_TRANSPORT_WS_PROTOCOL,
+            GRAPHQL_WS_PROTOCOL,
+        ),
+        connection_init_wait_timeout: timedelta = timedelta(minutes=1),
         multipart_uploads_enabled: bool = False,
     ) -> None:
         self.schema = schema
         self.allow_queries_via_get = allow_queries_via_get
+        self.keep_alive = keep_alive
+        self.keep_alive_interval = keep_alive_interval
+        self.debug = debug
+        self.subscription_protocols = subscription_protocols
+        self.connection_init_wait_timeout = connection_init_wait_timeout
         self.multipart_uploads_enabled = multipart_uploads_enabled
 
         if graphiql is not None:
@@ -88,18 +155,24 @@ class GraphQLView(
 
         return sub_response
 
-    async def get_context(self, request: Request, response: Response) -> Context:
+    async def get_context(
+        self, request: Union[Request, Websocket], response: Response
+    ) -> Context:
         return {"request": request, "response": response}  # type: ignore
 
-    async def get_root_value(self, request: Request) -> Optional[RootValue]:
+    async def get_root_value(
+        self, request: Union[Request, Websocket]
+    ) -> Optional[RootValue]:
         return None
 
     async def get_sub_response(self, request: Request) -> Response:
         return Response(status=200, content_type="application/json")
 
-    async def dispatch_request(self) -> "ResponseReturnValue":  # type: ignore
+    async def dispatch_request(self, **kwargs: object) -> "ResponseReturnValue":
         try:
-            return await self.run(request=request)
+            return await self.run(
+                request=websocket if has_websocket_context() else request
+            )
         except HTTPException as e:
             return Response(
                 response=e.reason,
@@ -122,16 +195,22 @@ class GraphQLView(
             },
         )
 
-    def is_websocket_request(self, request: Request) -> TypeGuard[Request]:
-        return False
+    def is_websocket_request(
+        self, request: Union[Request, Websocket]
+    ) -> TypeGuard[Websocket]:
+        return has_websocket_context()
 
-    async def pick_websocket_subprotocol(self, request: Request) -> Optional[str]:
-        raise NotImplementedError
+    async def pick_websocket_subprotocol(self, request: Websocket) -> Optional[str]:
+        protocols = request.requested_subprotocols
+        intersection = set(protocols) & set(self.subscription_protocols)
+        sorted_intersection = sorted(intersection, key=protocols.index)
+        return next(iter(sorted_intersection), None)
 
     async def create_websocket_response(
-        self, request: Request, subprotocol: Optional[str]
+        self, request: Websocket, subprotocol: Optional[str]
     ) -> Response:
-        raise NotImplementedError
+        await request.accept(subprotocol=subprotocol)
+        return Response()
 
 
 __all__ = ["GraphQLView"]

strawberry/schema/schema_converter.py

@@ -270,10 +270,7 @@ class GraphQLCoreConverter:
                 GlobalID,
                 name=global_id_name,
                 description=GraphQLID.description,
-                parse_literal=lambda v, vars=None: GlobalID.from_id(  # noqa: A006
-                    GraphQLID.parse_literal(v, vars)
-                ),
-                parse_value=GlobalID.from_id,
+                parse_value=lambda v: v,
                 serialize=str,
                 specified_by_url=("https://relay.dev/graphql/objectidentification.htm"),
             )
@@ -803,6 +800,13 @@ class GraphQLCoreConverter:
         return _resolver
 
     def from_scalar(self, scalar: type) -> GraphQLScalarType:
+        from strawberry.relay.types import GlobalID
+
+        if not self.config.relay_use_legacy_global_id and scalar is GlobalID:
+            from strawberry import ID
+
+            return self.from_scalar(ID)
+
         scalar_definition: ScalarDefinition
 
         if scalar in self.scalar_registry:
@@ -817,21 +821,13 @@ class GraphQLCoreConverter:
 
         scalar_name = self.config.name_converter.from_type(scalar_definition)
 
-        from strawberry.relay import GlobalID
-
         if scalar_name not in self.type_map:
-            if scalar is GlobalID and hasattr(GraphQLNamedType, "reserved_types"):
-                GraphQLNamedType.reserved_types.pop("ID")
-
             implementation = (
                 scalar_definition.implementation
                 if scalar_definition.implementation is not None
                 else _make_scalar_type(scalar_definition)
             )
 
-            if scalar is GlobalID and hasattr(GraphQLNamedType, "reserved_types"):
-                GraphQLNamedType.reserved_types["ID"] = implementation
-
             self.type_map[scalar_name] = ConcreteType(
                 definition=scalar_definition, implementation=implementation
             )
@@ -841,17 +837,7 @@ class GraphQLCoreConverter:
             # TODO: the other definition might not be a scalar, we should
             # handle this case better, since right now we assume it is a scalar
 
-            # special case to allow GlobalID to be used as an ID scalar
-            # TODO: we need to find a better way to handle this, might be
-            # worth reworking our scalar implementation.
-            if (
-                hasattr(other_definition, "origin")
-                and hasattr(scalar_definition, "origin")
-                and other_definition.origin == GlobalID
-                and scalar_definition.origin == GraphQLID
-            ):
-                pass
-            elif other_definition != scalar_definition:
+            if other_definition != scalar_definition:
                 other_definition = cast("ScalarDefinition", other_definition)
 
                 raise ScalarAlreadyRegisteredError(scalar_definition, other_definition)

strawberry/types/arguments.py

@@ -170,6 +170,11 @@ def convert_argument(
         ]
 
     if is_scalar(type_, scalar_registry):
+        from strawberry.relay.types import GlobalID
+
+        if type_ is GlobalID:
+            return GlobalID.from_id(value)  # type: ignore
+
         return value
 
     if isinstance(type_, EnumDefinition):

{strawberry_graphql-0.269.0.dev1747164009.dist-info → strawberry_graphql-0.270.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: strawberry-graphql
-Version: 0.269.0.dev1747164009
+Version: 0.270.1
 Summary: A library for creating GraphQL APIs
 License: MIT
 Keywords: graphql,api,rest,starlette,async

{strawberry_graphql-0.269.0.dev1747164009.dist-info → strawberry_graphql-0.270.1.dist-info}/RECORD

@@ -131,7 +131,7 @@ strawberry/file_uploads/utils.py,sha256=-c6TbqUI-Dkb96hWCrZabh6TL2OabBuQNkCarOqg
 strawberry/flask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 strawberry/flask/views.py,sha256=MCvAsNgTZLU8RvTYKWfnLU2w7Wv1ZZpxW9W3TyTZuPY,6355
 strawberry/http/__init__.py,sha256=ytAirKk7K7D5knY21tpCGeZ-sCPgwMsijL5AxmOy-94,1163
-strawberry/http/async_base_view.py,sha256=NnFYHy_3b6WtxRZoLCWDeOXDqEz2VxzG6jlKcIwrM4E,16519
+strawberry/http/async_base_view.py,sha256=RhCR58aHGpESgl_lSFSQgkrEFYFKCIE2SW5Lln5rxCo,20049
 strawberry/http/base.py,sha256=MiX0-RqOkhRvlfpmuvgTHp4tygbUmG8fnLc0uCrOllU,2550
 strawberry/http/exceptions.py,sha256=9E2dreS1crRoJVUEPuHyx23NcDELDHNzkAOa-rGv-8I,348
 strawberry/http/ides.py,sha256=WjU0nsMDgr3Bd1ebWkUEkO2d1hk0dI16mLqXyCHqklA,613
@@ -149,7 +149,7 @@ strawberry/printer/ast_from_value.py,sha256=Tkme60qlykbN2m3dNPNMOe65X-wj6EmcDQwg
 strawberry/printer/printer.py,sha256=49u3QwttTGvh13HXZtbTnkZzBwL1k5SLf8rXQLiTpl4,18814
 strawberry/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 strawberry/quart/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-strawberry/quart/views.py,sha256=Hjm93A9j9fy--DQVhsPQ_PakqYtajyWeuH7wUnSLYoA,4449
+strawberry/quart/views.py,sha256=f41HWnkGPuhs1NkjwHOZ0DEVnlr5nMSMr9GCxNsBxCs,7461
 strawberry/relay/__init__.py,sha256=Vi4btvA_g6Cj9Tk_F9GCSegapIf2WqkOWV8y3P0cTCs,553
 strawberry/relay/exceptions.py,sha256=Za0iXLBGZtd1HkesGm4xTr3QOeuyiCAe1hiCCQ2HHvE,4036
 strawberry/relay/fields.py,sha256=wIwBTXsDimG6incMglEn7Gr7CO8H8AA25yhM8MT8I-0,18100
@@ -168,7 +168,7 @@ strawberry/schema/config.py,sha256=KeZ1Pc1gvYK0fOx9Aghx7m0Av8sWexycl3HJGFgHPvg,9
 strawberry/schema/exceptions.py,sha256=rqVNb_oYrKM0dHPgvAemqCG6Um282LPPu4zwQ5cZqs4,584
 strawberry/schema/name_converter.py,sha256=xFOXEgqldFkxXRkIQvsJN1dPkWbEUaIrTYNOMYSEVwQ,6945
 strawberry/schema/schema.py,sha256=zRIv4mpVEFjFWv-MmfjO9v7OsuSFZ2xghr_ekIAuZI4,37113
-strawberry/schema/schema_converter.py,sha256=u12Og8eUX8SNMtJB6LYkj9zEpoQs-rDOXpN7tU8JG7k,39785
+strawberry/schema/schema_converter.py,sha256=_lKctaIfNcncVCan8AElYngGxMS8vf4Wy27tXfkr0Mk,39011
 strawberry/schema/types/__init__.py,sha256=oHO3COWhL3L1KLYCJNY1XFf5xt2GGtHiMC-UaYbFfnA,68
 strawberry/schema/types/base_scalars.py,sha256=JRUq0WjEkR9dFewstZnqnZKp0uOEipo4UXNF5dzRf4M,1971
 strawberry/schema/types/concrete_type.py,sha256=axIyFZgdwNv-XYkiqX67464wuFX6Vp0jYATwnBZSUvM,750
@@ -195,7 +195,7 @@ strawberry/tools/__init__.py,sha256=pdGpZx8wpq03VfUZJyF9JtYxZhGqzzxCiipsalWxJX4,
 strawberry/tools/create_type.py,sha256=--DgfZOmXJBKGcVxehNISyvpw1HzwFvRtUUPc0634MA,2056
 strawberry/tools/merge_types.py,sha256=hUMRRNM28FyPp70jRA3d4svv9WoEBjaNpihBt3DaY0I,1023
 strawberry/types/__init__.py,sha256=baWEdDkkmCcITOhkg2hNUOenrNV1OYdxGE5qgvIRwwU,351
-strawberry/types/arguments.py,sha256=Ut4H60a7SRuPtCUAa6gS6gJigaNqhCSesCPoeb0xDYE,9706
+strawberry/types/arguments.py,sha256=DVouyH70uvTcFP3PmRzo8QdMThoqXdigJbWE9Lgn5pU,9849
 strawberry/types/auto.py,sha256=WZ2cQAI8nREUigBzpzFqIKGjJ_C2VqpAPNe8vPjTciM,3007
 strawberry/types/base.py,sha256=tZSqxtrxXa1Y964HS2uakCbCgLyGO9A4WpODiegWzF8,15122
 strawberry/types/cast.py,sha256=fx86MkLW77GIximBAwUk5vZxSGwDqUA6XicXvz8EXwQ,916
@@ -229,8 +229,8 @@ strawberry/utils/logging.py,sha256=U1cseHGquN09YFhFmRkiphfASKCyK0HUZREImPgVb0c,7
 strawberry/utils/operation.py,sha256=s7ajvLg_q6v2mg47kEMQPjO_J-XluMKTCwo4d47mGvE,1195
 strawberry/utils/str_converters.py,sha256=-eH1Cl16IO_wrBlsGM-km4IY0IKsjhjnSNGRGOwQjVM,897
 strawberry/utils/typing.py,sha256=SDvX-Du-9HAV3-XXjqi7Q5f5qPDDFd_gASIITiwBQT4,14073
-strawberry_graphql-0.269.0.dev1747164009.dist-info/LICENSE,sha256=m-XnIVUKqlG_AWnfi9NReh9JfKhYOB-gJfKE45WM1W8,1072
-strawberry_graphql-0.269.0.dev1747164009.dist-info/METADATA,sha256=JpVEXkg2xDj9vjnGUpAV7_XvnIg6LV74yCj9xo6ZAR4,7693
-strawberry_graphql-0.269.0.dev1747164009.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-strawberry_graphql-0.269.0.dev1747164009.dist-info/entry_points.txt,sha256=Nk7-aT3_uEwCgyqtHESV9H6Mc31cK-VAvhnQNTzTb4k,49
-strawberry_graphql-0.269.0.dev1747164009.dist-info/RECORD,,
+strawberry_graphql-0.270.1.dist-info/LICENSE,sha256=m-XnIVUKqlG_AWnfi9NReh9JfKhYOB-gJfKE45WM1W8,1072
+strawberry_graphql-0.270.1.dist-info/METADATA,sha256=PImOblJFanhi8xQGrp8OGf8nIkxjjZhB5ox7CPrDljk,7679
+strawberry_graphql-0.270.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+strawberry_graphql-0.270.1.dist-info/entry_points.txt,sha256=Nk7-aT3_uEwCgyqtHESV9H6Mc31cK-VAvhnQNTzTb4k,49
+strawberry_graphql-0.270.1.dist-info/RECORD,,