strawberry-graphql 0.247.2__tar.gz → 0.248.1__tar.gz

{strawberry_graphql-0.247.2 → strawberry_graphql-0.248.1}/PKG-INFO

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

{strawberry_graphql-0.247.2 → strawberry_graphql-0.248.1}/pyproject.toml

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

{strawberry_graphql-0.247.2 → strawberry_graphql-0.248.1}/strawberry/channels/testing.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import dataclasses
 import uuid
 from typing import (
     TYPE_CHECKING,
@@ -26,10 +25,14 @@ from strawberry.subscriptions.protocols.graphql_transport_ws.types import (
     SubscribeMessage,
     SubscribeMessagePayload,
 )
-from strawberry.subscriptions.protocols.graphql_ws import (
-    GQL_CONNECTION_ACK,
-    GQL_CONNECTION_INIT,
-    GQL_START,
+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.types import ExecutionResult
 
@@ -108,13 +111,17 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
             await self.send_json_to(
                 ConnectionInitMessage(payload=self.connection_params).as_dict()
             )
-            response = await self.receive_json_from()
-            assert response == ConnectionAckMessage().as_dict()
+            graphql_transport_ws_response = await self.receive_json_from()
+            assert graphql_transport_ws_response == ConnectionAckMessage().as_dict()
         else:
             assert res == (True, GRAPHQL_WS_PROTOCOL)
-            await self.send_json_to({"type": GQL_CONNECTION_INIT})
-            response = await self.receive_json_from()
-            assert response["type"] == GQL_CONNECTION_ACK
+            await self.send_json_to(
+                GraphQLWSConnectionInitMessage({"type": "connection_init"})
+            )
+            graphql_ws_response: GraphQLWSConnectionAckMessage = (
+                await self.receive_json_from()
+            )
+            assert graphql_ws_response["type"] == "connection_ack"
 
     # Actual `ExecutionResult`` objects are not available client-side, since they
     # get transformed into `FormattedExecutionResult` on the wire, but we attempt
@@ -123,22 +130,28 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
         self, query: str, variables: Optional[Dict] = None
     ) -> Union[ExecutionResult, AsyncIterator[ExecutionResult]]:
         id_ = uuid.uuid4().hex
-        sub_payload = SubscribeMessagePayload(query=query, variables=variables)
+
         if self.protocol == GRAPHQL_TRANSPORT_WS_PROTOCOL:
             await self.send_json_to(
                 SubscribeMessage(
                     id=id_,
-                    payload=sub_payload,
+                    payload=SubscribeMessagePayload(query=query, variables=variables),
                 ).as_dict()
             )
         else:
-            await self.send_json_to(
-                {
-                    "type": GQL_START,
-                    "id": id_,
-                    "payload": dataclasses.asdict(sub_payload),
-                }
-            )
+            start_message: GraphQLWSStartMessage = {
+                "type": "start",
+                "id": id_,
+                "payload": {
+                    "query": query,
+                },
+            }
+
+            if variables is not None:
+                start_message["payload"]["variables"] = variables
+
+            await self.send_json_to(start_message)
+
         while True:
             response = await self.receive_json_from(timeout=5)
             message_type = response["type"]

{strawberry_graphql-0.247.2 → strawberry_graphql-0.248.1}/strawberry/cli/commands/codegen.py

@@ -4,7 +4,7 @@ import functools
 import importlib
 import inspect
 from pathlib import Path  # noqa: TCH003
-from typing import List, Optional, Type
+from typing import List, Optional, Type, Union, cast
 
 import rich
 import typer
@@ -61,7 +61,9 @@ def _import_plugin(plugin: str) -> Optional[Type[QueryCodegenPlugin]]:
 
 
 @functools.lru_cache
-def _load_plugin(plugin_path: str) -> Type[QueryCodegenPlugin]:
+def _load_plugin(
+    plugin_path: str,
+) -> Union[Type[QueryCodegenPlugin], Type[ConsolePlugin]]:
     # try to import plugin_name from current folder
     # then try to import from strawberry.codegen.plugins
 
@@ -77,7 +79,9 @@ def _load_plugin(plugin_path: str) -> Type[QueryCodegenPlugin]:
     return plugin
 
 
-def _load_plugins(plugin_ids: List[str], query: Path) -> List[QueryCodegenPlugin]:
+def _load_plugins(
+    plugin_ids: List[str], query: Path
+) -> List[Union[QueryCodegenPlugin, ConsolePlugin]]:
     plugins = []
     for ptype_id in plugin_ids:
         ptype = _load_plugin(ptype_id)
@@ -127,11 +131,11 @@ def codegen(
 
     console_plugin_type = _load_plugin(cli_plugin) if cli_plugin else ConsolePlugin
     console_plugin = console_plugin_type(output_dir)
+    assert isinstance(console_plugin, ConsolePlugin)
     console_plugin.before_any_start()
 
     for q in query:
-        plugins = _load_plugins(selected_plugins, q)
-        console_plugin.query = q  # update the query in the console plugin.
+        plugins = cast(List[QueryCodegenPlugin], _load_plugins(selected_plugins, q))
 
         code_generator = QueryCodegen(
             schema_symbol, plugins=plugins, console_plugin=console_plugin

{strawberry_graphql-0.247.2 → strawberry_graphql-0.248.1}/strawberry/experimental/pydantic/object_type.py

@@ -105,7 +105,7 @@ def _build_dataclass_creation_fields(
 
     return DataclassCreationFields(
         name=field.name,
-        field_type=field_type,
+        field_type=field_type,  # type: ignore
         field=strawberry_field,
     )
 
@@ -198,7 +198,7 @@ def type(
         all_model_fields = [
             DataclassCreationFields(
                 name=field.name,
-                field_type=field.type,
+                field_type=field.type,  # type: ignore
                 field=field,
             )
             for field in extra_fields + private_fields

{strawberry_graphql-0.247.2 → strawberry_graphql-0.248.1}/strawberry/subscriptions/protocols/graphql_ws/handlers.py

@@ -11,24 +11,18 @@ from typing import (
 )
 
 from strawberry.http.exceptions import NonTextMessageReceived, WebSocketDisconnected
-from strawberry.subscriptions.protocols.graphql_ws import (
-    GQL_COMPLETE,
-    GQL_CONNECTION_ACK,
-    GQL_CONNECTION_ERROR,
-    GQL_CONNECTION_INIT,
-    GQL_CONNECTION_KEEP_ALIVE,
-    GQL_CONNECTION_TERMINATE,
-    GQL_DATA,
-    GQL_ERROR,
-    GQL_START,
-    GQL_STOP,
-)
 from strawberry.subscriptions.protocols.graphql_ws.types import (
-    ConnectionInitPayload,
-    DataPayload,
+    CompleteMessage,
+    ConnectionAckMessage,
+    ConnectionErrorMessage,
+    ConnectionInitMessage,
+    ConnectionKeepAliveMessage,
+    ConnectionTerminateMessage,
+    DataMessage,
+    ErrorMessage,
     OperationMessage,
-    OperationMessagePayload,
-    StartPayload,
+    StartMessage,
+    StopMessage,
 )
 from strawberry.types.execution import ExecutionResult, PreExecutionError
 from strawberry.utils.debug import pretty_print_graphql_operation
@@ -59,7 +53,7 @@ class BaseGraphQLWSHandler:
         self.keep_alive_task: Optional[asyncio.Task] = None
         self.subscriptions: Dict[str, AsyncGenerator] = {}
         self.tasks: Dict[str, asyncio.Task] = {}
-        self.connection_params: Optional[ConnectionInitPayload] = None
+        self.connection_params: Optional[Dict[str, object]] = None
 
     async def handle(self) -> None:
         try:
@@ -87,41 +81,40 @@ class BaseGraphQLWSHandler:
         self,
         message: OperationMessage,
     ) -> None:
-        message_type = message["type"]
-
-        if message_type == GQL_CONNECTION_INIT:
+        if message["type"] == "connection_init":
             await self.handle_connection_init(message)
-        elif message_type == GQL_CONNECTION_TERMINATE:
+        elif message["type"] == "connection_terminate":
             await self.handle_connection_terminate(message)
-        elif message_type == GQL_START:
+        elif message["type"] == "start":
             await self.handle_start(message)
-        elif message_type == GQL_STOP:
+        elif message["type"] == "stop":
             await self.handle_stop(message)
 
-    async def handle_connection_init(self, message: OperationMessage) -> None:
+    async def handle_connection_init(self, message: ConnectionInitMessage) -> None:
         payload = message.get("payload")
         if payload is not None and not isinstance(payload, dict):
-            error_message: OperationMessage = {"type": GQL_CONNECTION_ERROR}
+            error_message: ConnectionErrorMessage = {"type": "connection_error"}
             await self.websocket.send_json(error_message)
             await self.websocket.close(code=1000, reason="")
             return
 
-        payload = cast(Optional["ConnectionInitPayload"], payload)
         self.connection_params = payload
 
-        acknowledge_message: OperationMessage = {"type": GQL_CONNECTION_ACK}
-        await self.websocket.send_json(acknowledge_message)
+        connection_ack_message: ConnectionAckMessage = {"type": "connection_ack"}
+        await self.websocket.send_json(connection_ack_message)
 
         if self.keep_alive:
             keep_alive_handler = self.handle_keep_alive()
             self.keep_alive_task = asyncio.create_task(keep_alive_handler)
 
-    async def handle_connection_terminate(self, message: OperationMessage) -> None:
+    async def handle_connection_terminate(
+        self, message: ConnectionTerminateMessage
+    ) -> None:
         await self.websocket.close(code=1000, reason="")
 
-    async def handle_start(self, message: OperationMessage) -> None:
+    async def handle_start(self, message: StartMessage) -> None:
         operation_id = message["id"]
-        payload = cast("StartPayload", message["payload"])
+        payload = message["payload"]
         query = payload["query"]
         operation_name = payload.get("operationName")
         variables = payload.get("variables")
@@ -139,14 +132,14 @@ class BaseGraphQLWSHandler:
         )
         self.tasks[operation_id] = asyncio.create_task(result_handler)
 
-    async def handle_stop(self, message: OperationMessage) -> None:
+    async def handle_stop(self, message: StopMessage) -> None:
         operation_id = message["id"]
         await self.cleanup_operation(operation_id)
 
     async def handle_keep_alive(self) -> None:
         assert self.keep_alive_interval
         while True:
-            data: OperationMessage = {"type": GQL_CONNECTION_KEEP_ALIVE}
+            data: ConnectionKeepAliveMessage = {"type": "ka"}
             await self.websocket.send_json(data)
             await asyncio.sleep(self.keep_alive_interval)
 
@@ -168,14 +161,25 @@ class BaseGraphQLWSHandler:
             if isinstance(agen_or_err, PreExecutionError):
                 assert agen_or_err.errors
                 error_payload = agen_or_err.errors[0].formatted
-                await self.send_message(GQL_ERROR, operation_id, error_payload)
+                error_message: ErrorMessage = {
+                    "type": "error",
+                    "id": operation_id,
+                    "payload": error_payload,
+                }
+                await self.websocket.send_json(error_message)
             else:
                 self.subscriptions[operation_id] = agen_or_err
+
                 async for result in agen_or_err:
                     await self.send_data(result, operation_id)
-                await self.send_message(GQL_COMPLETE, operation_id, None)
+
+                await self.websocket.send_json(
+                    CompleteMessage({"type": "complete", "id": operation_id})
+                )
         except asyncio.CancelledError:
-            await self.send_message(GQL_COMPLETE, operation_id, None)
+            await self.websocket.send_json(
+                CompleteMessage({"type": "complete", "id": operation_id})
+            )
 
     async def cleanup_operation(self, operation_id: str) -> None:
         if operation_id in self.subscriptions:
@@ -188,26 +192,24 @@ class BaseGraphQLWSHandler:
             await self.tasks[operation_id]
         del self.tasks[operation_id]
 
-    async def send_message(
-        self,
-        type_: str,
-        operation_id: str,
-        payload: Optional[OperationMessagePayload] = None,
-    ) -> None:
-        data: OperationMessage = {"type": type_, "id": operation_id}
-        if payload is not None:
-            data["payload"] = payload
-        await self.websocket.send_json(data)
-
     async def send_data(
         self, execution_result: ExecutionResult, operation_id: str
     ) -> None:
-        payload: DataPayload = {"data": execution_result.data}
+        data_message: DataMessage = {
+            "type": "data",
+            "id": operation_id,
+            "payload": {"data": execution_result.data},
+        }
+
         if execution_result.errors:
-            payload["errors"] = [err.formatted for err in execution_result.errors]
+            data_message["payload"]["errors"] = [
+                err.formatted for err in execution_result.errors
+            ]
+
         if execution_result.extensions:
-            payload["extensions"] = execution_result.extensions
-        await self.send_message(GQL_DATA, operation_id, payload)
+            data_message["payload"]["extensions"] = execution_result.extensions
+
+        await self.websocket.send_json(data_message)
 
 
 __all__ = ["BaseGraphQLWSHandler"]

strawberry_graphql-0.248.1/strawberry/subscriptions/protocols/graphql_ws/types.py

@@ -0,0 +1,96 @@
+from typing import Dict, List, TypedDict, Union
+from typing_extensions import Literal, NotRequired
+
+from graphql import GraphQLFormattedError
+
+
+class ConnectionInitMessage(TypedDict):
+    type: Literal["connection_init"]
+    payload: NotRequired[Dict[str, object]]
+
+
+class StartMessagePayload(TypedDict):
+    query: str
+    variables: NotRequired[Dict[str, object]]
+    operationName: NotRequired[str]
+
+
+class StartMessage(TypedDict):
+    type: Literal["start"]
+    id: str
+    payload: StartMessagePayload
+
+
+class StopMessage(TypedDict):
+    type: Literal["stop"]
+    id: str
+
+
+class ConnectionTerminateMessage(TypedDict):
+    type: Literal["connection_terminate"]
+
+
+class ConnectionErrorMessage(TypedDict):
+    type: Literal["connection_error"]
+    payload: NotRequired[Dict[str, object]]
+
+
+class ConnectionAckMessage(TypedDict):
+    type: Literal["connection_ack"]
+
+
+class DataMessagePayload(TypedDict):
+    data: object
+    errors: NotRequired[List[GraphQLFormattedError]]
+
+    # Non-standard field:
+    extensions: NotRequired[Dict[str, object]]
+
+
+class DataMessage(TypedDict):
+    type: Literal["data"]
+    id: str
+    payload: DataMessagePayload
+
+
+class ErrorMessage(TypedDict):
+    type: Literal["error"]
+    id: str
+    payload: GraphQLFormattedError
+
+
+class CompleteMessage(TypedDict):
+    type: Literal["complete"]
+    id: str
+
+
+class ConnectionKeepAliveMessage(TypedDict):
+    type: Literal["ka"]
+
+
+OperationMessage = Union[
+    ConnectionInitMessage,
+    StartMessage,
+    StopMessage,
+    ConnectionTerminateMessage,
+    ConnectionErrorMessage,
+    ConnectionAckMessage,
+    DataMessage,
+    ErrorMessage,
+    CompleteMessage,
+]
+
+
+__all__ = [
+    "ConnectionInitMessage",
+    "StartMessage",
+    "StopMessage",
+    "ConnectionTerminateMessage",
+    "ConnectionErrorMessage",
+    "ConnectionAckMessage",
+    "DataMessage",
+    "ErrorMessage",
+    "CompleteMessage",
+    "ConnectionKeepAliveMessage",
+    "OperationMessage",
+]

{strawberry_graphql-0.247.2 → strawberry_graphql-0.248.1}/strawberry/utils/typing.py

@@ -350,7 +350,12 @@ def eval_type(
         assert ast_unparse
         type_ = ForwardRef(ast_unparse(ast_obj))
 
-        return _eval_type(type_, globalns, localns)
+        extra: Dict[str, Any] = {}
+
+        if sys.version_info >= (3, 13):
+            extra = {"type_params": None}
+
+        return _eval_type(type_, globalns, localns, **extra)
 
     origin = get_origin(type_)
     if origin is not None:

strawberry_graphql-0.247.2/strawberry/subscriptions/protocols/graphql_ws/__init__.py

@@ -1,24 +0,0 @@
-GQL_CONNECTION_INIT = "connection_init"
-GQL_CONNECTION_ACK = "connection_ack"
-GQL_CONNECTION_ERROR = "connection_error"
-GQL_CONNECTION_TERMINATE = "connection_terminate"
-GQL_CONNECTION_KEEP_ALIVE = "ka"
-GQL_START = "start"
-GQL_DATA = "data"
-GQL_ERROR = "error"
-GQL_COMPLETE = "complete"
-GQL_STOP = "stop"
-
-
-__all__ = [
-    "GQL_CONNECTION_INIT",
-    "GQL_CONNECTION_ACK",
-    "GQL_CONNECTION_ERROR",
-    "GQL_CONNECTION_TERMINATE",
-    "GQL_CONNECTION_KEEP_ALIVE",
-    "GQL_START",
-    "GQL_DATA",
-    "GQL_ERROR",
-    "GQL_COMPLETE",
-    "GQL_STOP",
-]

strawberry_graphql-0.247.2/strawberry/subscriptions/protocols/graphql_ws/types.py

@@ -1,52 +0,0 @@
-from typing import Any, Dict, List, Optional, Union
-from typing_extensions import TypedDict
-
-from graphql import GraphQLFormattedError
-
-ConnectionInitPayload = Dict[str, Any]
-
-
-ConnectionErrorPayload = Dict[str, Any]
-
-
-class StartPayload(TypedDict, total=False):
-    query: str
-    variables: Optional[Dict[str, Any]]
-    operationName: Optional[str]
-
-
-class DataPayload(TypedDict, total=False):
-    data: Any
-
-    # Optional list of formatted graphql.GraphQLError objects
-    errors: Optional[List[GraphQLFormattedError]]
-    extensions: Optional[Dict[str, Any]]
-
-
-ErrorPayload = GraphQLFormattedError
-
-
-OperationMessagePayload = Union[
-    ConnectionInitPayload,
-    ConnectionErrorPayload,
-    StartPayload,
-    DataPayload,
-    ErrorPayload,
-]
-
-
-class OperationMessage(TypedDict, total=False):
-    type: str
-    id: str
-    payload: OperationMessagePayload
-
-
-__all__ = [
-    "ConnectionInitPayload",
-    "ConnectionErrorPayload",
-    "StartPayload",
-    "DataPayload",
-    "ErrorPayload",
-    "OperationMessagePayload",
-    "OperationMessage",
-]