strawberry-graphql 0.249.0__py3-none-any.whl → 0.250.0__py3-none-any.whl

strawberry/channels/testing.py

@@ -17,23 +17,10 @@ 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.types import (
-    ConnectionAckMessage,
-    ConnectionInitMessage,
-    ErrorMessage,
-    NextMessage,
-    SubscribeMessage,
-    SubscribeMessagePayload,
-)
-from strawberry.subscriptions.protocols.graphql_ws.types import (
-    ConnectionAckMessage as GraphQLWSConnectionAckMessage,
-)
-from strawberry.subscriptions.protocols.graphql_ws.types import (
-    ConnectionInitMessage as GraphQLWSConnectionInitMessage,
-)
-from strawberry.subscriptions.protocols.graphql_ws.types import (
-    StartMessage as GraphQLWSStartMessage,
+from strawberry.subscriptions.protocols.graphql_transport_ws import (
+    types as transport_ws_types,
 )
+from strawberry.subscriptions.protocols.graphql_ws import types as ws_types
 from strawberry.types import ExecutionResult
 
 if TYPE_CHECKING:
@@ -109,19 +96,21 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
         if self.protocol == GRAPHQL_TRANSPORT_WS_PROTOCOL:
             assert res == (True, GRAPHQL_TRANSPORT_WS_PROTOCOL)
             await self.send_json_to(
-                ConnectionInitMessage(payload=self.connection_params).as_dict()
+                transport_ws_types.ConnectionInitMessage(
+                    {"type": "connection_init", "payload": self.connection_params}
+                )
             )
-            graphql_transport_ws_response = await self.receive_json_from()
-            assert graphql_transport_ws_response == ConnectionAckMessage().as_dict()
+            transport_ws_connection_ack_message: transport_ws_types.ConnectionAckMessage = await self.receive_json_from()
+            assert transport_ws_connection_ack_message == {"type": "connection_ack"}
         else:
             assert res == (True, GRAPHQL_WS_PROTOCOL)
             await self.send_json_to(
-                GraphQLWSConnectionInitMessage({"type": "connection_init"})
+                ws_types.ConnectionInitMessage({"type": "connection_init"})
             )
-            graphql_ws_response: GraphQLWSConnectionAckMessage = (
+            ws_connection_ack_message: ws_types.ConnectionAckMessage = (
                 await self.receive_json_from()
             )
-            assert graphql_ws_response["type"] == "connection_ack"
+            assert ws_connection_ack_message["type"] == "connection_ack"
 
     # Actual `ExecutionResult`` objects are not available client-side, since they
     # get transformed into `FormattedExecutionResult` on the wire, but we attempt
@@ -133,13 +122,16 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
 
         if self.protocol == GRAPHQL_TRANSPORT_WS_PROTOCOL:
             await self.send_json_to(
-                SubscribeMessage(
-                    id=id_,
-                    payload=SubscribeMessagePayload(query=query, variables=variables),
-                ).as_dict()
+                transport_ws_types.SubscribeMessage(
+                    {
+                        "id": id_,
+                        "type": "subscribe",
+                        "payload": {"query": query, "variables": variables},
+                    }
+                )
             )
         else:
-            start_message: GraphQLWSStartMessage = {
+            start_message: ws_types.StartMessage = {
                 "type": "start",
                 "id": id_,
                 "payload": {
@@ -153,17 +145,18 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
             await self.send_json_to(start_message)
 
         while True:
-            response = await self.receive_json_from(timeout=5)
-            message_type = response["type"]
-            if message_type == NextMessage.type:
-                payload = NextMessage(**response).payload
+            message: transport_ws_types.Message = await self.receive_json_from(
+                timeout=5
+            )
+            if message["type"] == "next":
+                payload = message["payload"]
                 ret = ExecutionResult(payload.get("data"), None)
                 if "errors" in payload:
                     ret.errors = self.process_errors(payload.get("errors") or [])
                 ret.extensions = payload.get("extensions", None)
                 yield ret
-            elif message_type == ErrorMessage.type:
-                error_payload = ErrorMessage(**response).payload
+            elif message["type"] == "error":
+                error_payload = message["payload"]
                 yield ExecutionResult(
                     data=None, errors=self.process_errors(error_payload)
                 )

strawberry/permission.py

@@ -177,8 +177,7 @@ class PermissionExtension(FieldExtension):
             elif isinstance(field.type, StrawberryList):
                 self.return_empty_list = True
             else:
-                errror = PermissionFailSilentlyRequiresOptionalError(field)
-                raise errror
+                raise PermissionFailSilentlyRequiresOptionalError(field)
 
     def _on_unauthorized(self, permission: BasePermission) -> Any:
         if self.fail_silently:

strawberry/subscriptions/protocols/graphql_transport_ws/handlers.py

@@ -5,11 +5,11 @@ import logging
 from contextlib import suppress
 from typing import (
     TYPE_CHECKING,
-    Any,
     Awaitable,
     Dict,
     List,
     Optional,
+    cast,
 )
 
 from graphql import GraphQLError, GraphQLSyntaxError, parse
@@ -21,20 +21,16 @@ from strawberry.http.exceptions import (
 )
 from strawberry.subscriptions.protocols.graphql_transport_ws.types import (
     CompleteMessage,
-    ConnectionAckMessage,
     ConnectionInitMessage,
-    ErrorMessage,
-    NextMessage,
-    NextPayload,
+    Message,
+    NextMessagePayload,
     PingMessage,
     PongMessage,
     SubscribeMessage,
-    SubscribeMessagePayload,
 )
 from strawberry.types import ExecutionResult
 from strawberry.types.execution import PreExecutionError
 from strawberry.types.graphql import OperationType
-from strawberry.types.unset import UNSET
 from strawberry.utils.debug import pretty_print_graphql_operation
 from strawberry.utils.operation import get_operation_type
 
@@ -44,9 +40,6 @@ if TYPE_CHECKING:
     from strawberry.http.async_base_view import AsyncWebSocketAdapter
     from strawberry.schema import BaseSchema
     from strawberry.schema.subscribe import SubscriptionResult
-    from strawberry.subscriptions.protocols.graphql_transport_ws.types import (
-        GraphQLTransportMessage,
-    )
 
 
 class BaseGraphQLTransportWSHandler:
@@ -73,15 +66,15 @@ class BaseGraphQLTransportWSHandler:
         self.connection_timed_out = False
         self.operations: Dict[str, Operation] = {}
         self.completed_tasks: List[asyncio.Task] = []
-        self.connection_params: Optional[Dict[str, Any]] = None
+        self.connection_params: Optional[Dict[str, object]] = None
 
-    async def handle(self) -> Any:
+    async def handle(self) -> None:
         self.on_request_accepted()
 
         try:
             try:
                 async for message in self.websocket.iter_json():
-                    await self.handle_message(message)
+                    await self.handle_message(cast(Message, message))
             except NonTextMessageReceived:
                 await self.handle_invalid_message("WebSocket message type must be text")
             except NonJsonMessageReceived:
@@ -134,39 +127,28 @@ class BaseGraphQLTransportWSHandler:
     async def handle_task_exception(self, error: Exception) -> None:  # pragma: no cover
         self.task_logger.exception("Exception in worker task", exc_info=error)
 
-    async def handle_message(self, message: dict) -> None:
+    async def handle_message(self, message: Message) -> None:
         try:
-            message_type = message.pop("type")
+            if message["type"] == "connection_init":
+                await self.handle_connection_init(message)
 
-            if message_type == ConnectionInitMessage.type:
-                await self.handle_connection_init(ConnectionInitMessage(**message))
+            elif message["type"] == "ping":
+                await self.handle_ping(message)
 
-            elif message_type == PingMessage.type:
-                await self.handle_ping(PingMessage(**message))
+            elif message["type"] == "pong":
+                await self.handle_pong(message)
 
-            elif message_type == PongMessage.type:
-                await self.handle_pong(PongMessage(**message))
+            elif message["type"] == "subscribe":
+                await self.handle_subscribe(message)
 
-            elif message_type == SubscribeMessage.type:
-                payload_args = message.pop("payload")
-                payload = SubscribeMessagePayload(
-                    query=payload_args["query"],
-                    operationName=payload_args.get("operationName"),
-                    variables=payload_args.get("variables"),
-                    extensions=payload_args.get("extensions"),
-                )
-                await self.handle_subscribe(
-                    SubscribeMessage(payload=payload, **message)
-                )
-
-            elif message_type == CompleteMessage.type:
-                await self.handle_complete(CompleteMessage(**message))
+            elif message["type"] == "complete":
+                await self.handle_complete(message)
 
             else:
-                error_message = f"Unknown message type: {message_type}"
+                error_message = f"Unknown message type: {message['type']}"
                 await self.handle_invalid_message(error_message)
 
-        except (KeyError, TypeError):
+        except KeyError:
             await self.handle_invalid_message("Failed to parse message")
         finally:
             await self.reap_completed_tasks()
@@ -175,14 +157,11 @@ class BaseGraphQLTransportWSHandler:
         if self.connection_timed_out:
             # No way to reliably excercise this case during testing
             return  # pragma: no cover
+
         if self.connection_init_timeout_task:
             self.connection_init_timeout_task.cancel()
 
-        payload = (
-            message.payload
-            if message.payload is not None and message.payload is not UNSET
-            else {}
-        )
+        payload = message.get("payload", {})
 
         if not isinstance(payload, dict):
             await self.websocket.close(
@@ -198,11 +177,11 @@ class BaseGraphQLTransportWSHandler:
             return
 
         self.connection_init_received = True
-        await self.send_message(ConnectionAckMessage())
+        await self.send_message({"type": "connection_ack"})
         self.connection_acknowledged = True
 
     async def handle_ping(self, message: PingMessage) -> None:
-        await self.send_message(PongMessage())
+        await self.send_message({"type": "pong"})
 
     async def handle_pong(self, message: PongMessage) -> None:
         pass
@@ -213,14 +192,14 @@ class BaseGraphQLTransportWSHandler:
             return
 
         try:
-            graphql_document = parse(message.payload.query)
+            graphql_document = parse(message["payload"]["query"])
         except GraphQLSyntaxError as exc:
             await self.websocket.close(code=4400, reason=exc.message)
             return
 
         try:
             operation_type = get_operation_type(
-                graphql_document, message.payload.operationName
+                graphql_document, message["payload"].get("operationName")
             )
         except RuntimeError:
             await self.websocket.close(
@@ -228,16 +207,16 @@ class BaseGraphQLTransportWSHandler:
             )
             return
 
-        if message.id in self.operations:
-            reason = f"Subscriber for {message.id} already exists"
+        if message["id"] in self.operations:
+            reason = f"Subscriber for {message['id']} already exists"
             await self.websocket.close(code=4409, reason=reason)
             return
 
         if self.debug:  # pragma: no cover
             pretty_print_graphql_operation(
-                message.payload.operationName,
-                message.payload.query,
-                message.payload.variables,
+                message["payload"].get("operationName"),
+                message["payload"]["query"],
+                message["payload"].get("variables"),
             )
 
         if isinstance(self.context, dict):
@@ -247,15 +226,15 @@ class BaseGraphQLTransportWSHandler:
 
         operation = Operation(
             self,
-            message.id,
+            message["id"],
             operation_type,
-            message.payload.query,
-            message.payload.variables,
-            message.payload.operationName,
+            message["payload"]["query"],
+            message["payload"].get("variables"),
+            message["payload"].get("operationName"),
         )
 
         operation.task = asyncio.create_task(self.run_operation(operation))
-        self.operations[message.id] = operation
+        self.operations[message["id"]] = operation
 
     async def run_operation(self, operation: Operation) -> None:
         """The operation task's top level method. Cleans-up and de-registers the operation once it is done."""
@@ -291,11 +270,15 @@ class BaseGraphQLTransportWSHandler:
             # that's a mutation / query result
             elif isinstance(first_res_or_agen, ExecutionResult):
                 await operation.send_next(first_res_or_agen)
-                await operation.send_message(CompleteMessage(id=operation.id))
+                await operation.send_operation_message(
+                    {"id": operation.id, "type": "complete"}
+                )
             else:
                 async for result in first_res_or_agen:
                     await operation.send_next(result)
-                await operation.send_message(CompleteMessage(id=operation.id))
+                await operation.send_operation_message(
+                    {"id": operation.id, "type": "complete"}
+                )
 
         except BaseException as e:  # pragma: no cover
             self.operations.pop(operation.id, None)
@@ -312,14 +295,13 @@ class BaseGraphQLTransportWSHandler:
         del self.operations[id]
 
     async def handle_complete(self, message: CompleteMessage) -> None:
-        await self.cleanup_operation(operation_id=message.id)
+        await self.cleanup_operation(operation_id=message["id"])
 
     async def handle_invalid_message(self, error_message: str) -> None:
         await self.websocket.close(code=4400, reason=error_message)
 
-    async def send_message(self, message: GraphQLTransportMessage) -> None:
-        data = message.as_dict()
-        await self.websocket.send_json(data)
+    async def send_message(self, message: Message) -> None:
+        await self.websocket.send_json(message)
 
     async def cleanup_operation(self, operation_id: str) -> None:
         if operation_id not in self.operations:
@@ -358,7 +340,7 @@ class Operation:
         id: str,
         operation_type: OperationType,
         query: str,
-        variables: Optional[Dict[str, Any]],
+        variables: Optional[Dict[str, object]],
         operation_name: Optional[str],
     ) -> None:
         self.handler = handler
@@ -370,10 +352,10 @@ class Operation:
         self.completed = False
         self.task: Optional[asyncio.Task] = None
 
-    async def send_message(self, message: GraphQLTransportMessage) -> None:
+    async def send_operation_message(self, message: Message) -> None:
         if self.completed:
             return
-        if isinstance(message, (CompleteMessage, ErrorMessage)):
+        if message["type"] == "complete" or message["type"] == "error":
             self.completed = True
             # de-register the operation _before_ sending the final message
             self.handler.forget_id(self.id)
@@ -383,17 +365,26 @@ class Operation:
         # Initial errors see https://github.com/enisdenjo/graphql-ws/blob/master/PROTOCOL.md#error
         # "This can occur before execution starts,
         # usually due to validation errors, or during the execution of the request"
-        await self.send_message(
-            ErrorMessage(id=self.id, payload=[err.formatted for err in errors])
+        await self.send_operation_message(
+            {
+                "id": self.id,
+                "type": "error",
+                "payload": [err.formatted for err in errors],
+            }
         )
 
     async def send_next(self, execution_result: ExecutionResult) -> None:
-        next_payload: NextPayload = {"data": execution_result.data}
+        next_payload: NextMessagePayload = {"data": execution_result.data}
+
         if execution_result.errors:
             next_payload["errors"] = [err.formatted for err in execution_result.errors]
+
         if execution_result.extensions:
             next_payload["extensions"] = execution_result.extensions
-        await self.send_message(NextMessage(id=self.id, payload=next_payload))
+
+        await self.send_operation_message(
+            {"id": self.id, "type": "next", "payload": next_payload}
+        )
 
 
 __all__ = ["BaseGraphQLTransportWSHandler", "Operation"]

strawberry/subscriptions/protocols/graphql_transport_ws/types.py

@@ -1,108 +1,91 @@
-from __future__ import annotations
+from typing import Dict, List, TypedDict, Union
+from typing_extensions import Literal, NotRequired
 
-from dataclasses import asdict, dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, TypedDict
+from graphql import GraphQLFormattedError
 
-from strawberry.types.unset import UNSET
 
-if TYPE_CHECKING:
-    from graphql import GraphQLFormattedError
-
-
-@dataclass
-class GraphQLTransportMessage:
-    def as_dict(self) -> dict:
-        data = asdict(self)
-        if getattr(self, "payload", None) is UNSET:
-            # Unset fields must have a JSON value of "undefined" not "null"
-            data.pop("payload")
-        return data
-
-
-@dataclass
-class ConnectionInitMessage(GraphQLTransportMessage):
+class ConnectionInitMessage(TypedDict):
     """Direction: Client -> Server."""
 
-    payload: Optional[Dict[str, Any]] = UNSET
-    type: str = "connection_init"
+    type: Literal["connection_init"]
+    payload: NotRequired[Union[Dict[str, object], None]]
 
 
-@dataclass
-class ConnectionAckMessage(GraphQLTransportMessage):
+class ConnectionAckMessage(TypedDict):
     """Direction: Server -> Client."""
 
-    payload: Optional[Dict[str, Any]] = UNSET
-    type: str = "connection_ack"
+    type: Literal["connection_ack"]
+    payload: NotRequired[Union[Dict[str, object], None]]
 
 
-@dataclass
-class PingMessage(GraphQLTransportMessage):
+class PingMessage(TypedDict):
     """Direction: bidirectional."""
 
-    payload: Optional[Dict[str, Any]] = UNSET
-    type: str = "ping"
+    type: Literal["ping"]
+    payload: NotRequired[Union[Dict[str, object], None]]
 
 
-@dataclass
-class PongMessage(GraphQLTransportMessage):
+class PongMessage(TypedDict):
     """Direction: bidirectional."""
 
-    payload: Optional[Dict[str, Any]] = UNSET
-    type: str = "pong"
+    type: Literal["pong"]
+    payload: NotRequired[Union[Dict[str, object], None]]
 
 
-@dataclass
-class SubscribeMessagePayload:
+class SubscribeMessagePayload(TypedDict):
+    operationName: NotRequired[Union[str, None]]
     query: str
-    operationName: Optional[str] = None
-    variables: Optional[Dict[str, Any]] = None
-    extensions: Optional[Dict[str, Any]] = None
+    variables: NotRequired[Union[Dict[str, object], None]]
+    extensions: NotRequired[Union[Dict[str, object], None]]
 
 
-@dataclass
-class SubscribeMessage(GraphQLTransportMessage):
+class SubscribeMessage(TypedDict):
     """Direction: Client -> Server."""
 
     id: str
+    type: Literal["subscribe"]
     payload: SubscribeMessagePayload
-    type: str = "subscribe"
 
 
-class NextPayload(TypedDict, total=False):
-    data: Any
+class NextMessagePayload(TypedDict):
+    errors: NotRequired[List[GraphQLFormattedError]]
+    data: NotRequired[Union[Dict[str, object], None]]
+    extensions: NotRequired[Dict[str, object]]
 
-    # Optional list of formatted graphql.GraphQLError objects
-    errors: Optional[List[GraphQLFormattedError]]
-    extensions: Optional[Dict[str, Any]]
 
-
-@dataclass
-class NextMessage(GraphQLTransportMessage):
+class NextMessage(TypedDict):
     """Direction: Server -> Client."""
 
     id: str
-    payload: NextPayload
-    type: str = "next"
-
-    def as_dict(self) -> dict:
-        return {"id": self.id, "payload": self.payload, "type": self.type}
+    type: Literal["next"]
+    payload: NextMessagePayload
 
 
-@dataclass
-class ErrorMessage(GraphQLTransportMessage):
+class ErrorMessage(TypedDict):
     """Direction: Server -> Client."""
 
     id: str
+    type: Literal["error"]
     payload: List[GraphQLFormattedError]
-    type: str = "error"
 
 
-@dataclass
-class CompleteMessage(GraphQLTransportMessage):
+class CompleteMessage(TypedDict):
     """Direction: bidirectional."""
 
     id: str
-    type: str = "complete"
+    type: Literal["complete"]
+
+
+Message = Union[
+    ConnectionInitMessage,
+    ConnectionAckMessage,
+    PingMessage,
+    PongMessage,
+    SubscribeMessage,
+    NextMessage,
+    ErrorMessage,
+    CompleteMessage,
+]
 
 
 __all__ = [
@@ -114,4 +97,5 @@ __all__ = [
     "NextMessage",
     "ErrorMessage",
     "CompleteMessage",
+    "Message",
 ]

{strawberry_graphql-0.249.0.dist-info → strawberry_graphql-0.250.0.dist-info}/METADATA

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

{strawberry_graphql-0.249.0.dist-info → strawberry_graphql-0.250.0.dist-info}/RECORD

@@ -16,7 +16,7 @@ strawberry/channels/handlers/base.py,sha256=KV4KA0eF5NRtikV9m4ssoPI5pmCZvDuRkfoT
 strawberry/channels/handlers/http_handler.py,sha256=fnQcPwdUz2CboVlnI3s1urQ_ZnZyNZvRx7SM_xPLLEA,11577
 strawberry/channels/handlers/ws_handler.py,sha256=k9xax8S1g0tfEFSe76UOHkheHqIrnYjEioYlLm4UPLo,6052
 strawberry/channels/router.py,sha256=DKIbl4zuRBhfvViUVpyu0Rf_WRT41E6uZC-Yic9Ltvo,2024
-strawberry/channels/testing.py,sha256=2cZvF9S4ofYLLRh2G8iyWZTphfQi7XrUcFpRqGjUmPQ,6688
+strawberry/channels/testing.py,sha256=0q7XQi3uOa-WbqXTkZKWwsLH2B8IHfP3JAXF-b-1qM4,6490
 strawberry/cli/__init__.py,sha256=byS5VrEiTJatAH6YS4V1Kd4SOwMRAQO2M1oJdIddivg,585
 strawberry/cli/app.py,sha256=tTMBV1pdWqMcwjWO2yn-8oLDhMhfJvUzyQtWs75LWJ0,54
 strawberry/cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -143,7 +143,7 @@ strawberry/http/typevars.py,sha256=8hK5PfNPZXb2EhZmqlobYyfwJJcO2Wb96T91MlLEVJs,4
 strawberry/litestar/__init__.py,sha256=zsXzg-mglCGUVO9iNXLm-yadoDSCK7k-zuyRqyvAh1w,237
 strawberry/litestar/controller.py,sha256=yA8f59NuC6ZJgpG2p4HoILko3FdWiNx5AWdkQGti_6U,13992
 strawberry/parent.py,sha256=sXURm0lauSpjUADsmfNGY-Zl7kHs0A67BFcWuWKzRxw,771
-strawberry/permission.py,sha256=HusiB46yZANdpZM3AdzFVZB6JkCu7dcvoZ3QP2E01jM,7575
+strawberry/permission.py,sha256=rCJLK21cRNDQ6N9eSqcEiIUZiuCvF3FVOK3onXGai9E,7543
 strawberry/printer/__init__.py,sha256=DmepjmgtkdF5RxK_7yC6qUyRWn56U-9qeZMbkztYB9w,62
 strawberry/printer/ast_from_value.py,sha256=LgM5g2qvBOnAIf9znbiMEcRX0PGSQohR3Vr3QYfU604,4983
 strawberry/printer/printer.py,sha256=GntTBivg3fb_zPM41Q8DtWMiRmkmM9xwTF-aFWvnqTg,17524
@@ -186,8 +186,8 @@ strawberry/static/pathfinder.html,sha256=0DPx9AmJ2C_sJstFXnWOz9k5tVQHeHaK7qdVY4l
 strawberry/subscriptions/__init__.py,sha256=1VGmiCzFepqRFyCikagkUoHHdoTG3XYlFu9GafoQMws,170
 strawberry/subscriptions/protocols/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 strawberry/subscriptions/protocols/graphql_transport_ws/__init__.py,sha256=wN6dkMu6WiaIZTE19PGoN9xXpIN_RdDE_q7F7ZgjCxk,138
-strawberry/subscriptions/protocols/graphql_transport_ws/handlers.py,sha256=_h-xNf_ZRtjn8PGbxZk3u9qTR-NNNCevdgaFF0uXciw,14728
-strawberry/subscriptions/protocols/graphql_transport_ws/types.py,sha256=udYxzGtwjETYvY5f23org0t-aY4cimTjEGFYUR3idaY,2596
+strawberry/subscriptions/protocols/graphql_transport_ws/handlers.py,sha256=R9QCGHJ_lf0gmNf_wzt4Ow-HFA5ulFsGUiNo_K3CHkI,14104
+strawberry/subscriptions/protocols/graphql_transport_ws/types.py,sha256=AtKPEyFuNIKgnIIBD-MC4kAYFQ6uhXeq3xyRF6Dh-hg,2181
 strawberry/subscriptions/protocols/graphql_ws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 strawberry/subscriptions/protocols/graphql_ws/handlers.py,sha256=oM0o85zC24LpBjtVq8VakKx2hBGL0kb3Q9yl0GyFLS8,7614
 strawberry/subscriptions/protocols/graphql_ws/types.py,sha256=diZ36w56Nb_YmgfWXe6uXGiQOKmWIVjNEkcM-PkjaSs,1939
@@ -229,8 +229,8 @@ strawberry/utils/logging.py,sha256=U1cseHGquN09YFhFmRkiphfASKCyK0HUZREImPgVb0c,7
 strawberry/utils/operation.py,sha256=SSXxN-vMqdHO6W2OZtip-1z7y4_A-eTVFdhDvhKeLCk,1193
 strawberry/utils/str_converters.py,sha256=KGd7QH90RevaJjH6SQEkiVVsb8KuhJr_wv5AsI7UzQk,897
 strawberry/utils/typing.py,sha256=G6k2wWD1TDQ9WFk-Togekj_hTVFqHV-g7Phf2Wu41ms,14380
-strawberry_graphql-0.249.0.dist-info/LICENSE,sha256=m-XnIVUKqlG_AWnfi9NReh9JfKhYOB-gJfKE45WM1W8,1072
-strawberry_graphql-0.249.0.dist-info/METADATA,sha256=y_NXnqJCCHmKI10lZ-r3oodKQHkth_DvEmUTsYaThVc,7758
-strawberry_graphql-0.249.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-strawberry_graphql-0.249.0.dist-info/entry_points.txt,sha256=Nk7-aT3_uEwCgyqtHESV9H6Mc31cK-VAvhnQNTzTb4k,49
-strawberry_graphql-0.249.0.dist-info/RECORD,,
+strawberry_graphql-0.250.0.dist-info/LICENSE,sha256=m-XnIVUKqlG_AWnfi9NReh9JfKhYOB-gJfKE45WM1W8,1072
+strawberry_graphql-0.250.0.dist-info/METADATA,sha256=4VaLyKu8LPZoMQwYXdWBxpVCoVtEM5JVKH6bST7gY3U,7758
+strawberry_graphql-0.250.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+strawberry_graphql-0.250.0.dist-info/entry_points.txt,sha256=Nk7-aT3_uEwCgyqtHESV9H6Mc31cK-VAvhnQNTzTb4k,49
+strawberry_graphql-0.250.0.dist-info/RECORD,,