strawberry-graphql 0.269.0.dev1746905409__tar.gz → 0.270.0__tar.gz

{strawberry_graphql-0.269.0.dev1746905409 → strawberry_graphql-0.270.0}/PKG-INFO

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

{strawberry_graphql-0.269.0.dev1746905409 → strawberry_graphql-0.270.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "strawberry-graphql"
-version = "0.269.0.dev.1746905409"
+version = "0.270.0"
 packages = [{ include = "strawberry" }]
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]

{strawberry_graphql-0.269.0.dev1746905409 → strawberry_graphql-0.270.0}/strawberry/__init__.py

@@ -11,7 +11,6 @@ from .permission import BasePermission
 from .scalars import ID
 from .schema import Schema
 from .schema_directive import schema_directive
-from .streamable import Streamable
 from .types.arguments import argument
 from .types.auto import auto
 from .types.cast import cast
@@ -38,7 +37,6 @@ __all__ = [
     "Private",
     "Schema",
     "Some",
-    "Streamable",
     "argument",
     "asdict",
     "auto",

{strawberry_graphql-0.269.0.dev1746905409 → strawberry_graphql-0.270.0}/strawberry/annotation.py

@@ -17,7 +17,6 @@ from typing import (
 )
 from typing_extensions import Self, get_args, get_origin
 
-from strawberry.streamable import StrawberryStreamable
 from strawberry.types.base import (
     StrawberryList,
     StrawberryMaybe,
@@ -144,8 +143,6 @@ class StrawberryAnnotation:
 
         if self._is_lazy_type(evaled_type):
             return evaled_type
-        if self._is_streamable(evaled_type, args):
-            return self.create_list(list[evaled_type])
         if self._is_list(evaled_type):
             return self.create_list(evaled_type)
         if type_of := self._get_maybe_type(evaled_type):
@@ -326,10 +323,6 @@ class StrawberryAnnotation:
     def _get_maybe_type(cls, annotation: Any) -> type | None:
         return get_args(annotation)[0] if _annotation_is_maybe(annotation) else None
 
-    @classmethod
-    def _is_streamable(cls, annotation: Any, args: list[Any]) -> bool:
-        return any(isinstance(arg, StrawberryStreamable) for arg in args)
-
     @classmethod
     def _is_strawberry_type(cls, evaled_type: Any) -> bool:
         # Prevent import cycles

{strawberry_graphql-0.269.0.dev1746905409 → strawberry_graphql-0.270.0}/strawberry/http/__init__.py

@@ -1,13 +1,11 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Optional
+from typing import TYPE_CHECKING, Any, Optional
 from typing_extensions import Literal, TypedDict
 
-from strawberry.schema._graphql_core import (
-    GraphQLIncrementalExecutionResults,
-    ResultType,
-)
+if TYPE_CHECKING:
+    from strawberry.types import ExecutionResult
 
 
 class GraphQLHTTPResponse(TypedDict, total=False):
@@ -16,16 +14,13 @@ class GraphQLHTTPResponse(TypedDict, total=False):
     extensions: Optional[dict[str, object]]
 
 
-def process_result(result: ResultType) -> GraphQLHTTPResponse:
-    if isinstance(result, GraphQLIncrementalExecutionResults):
-        return result
+def process_result(result: ExecutionResult) -> GraphQLHTTPResponse:
+    data: GraphQLHTTPResponse = {"data": result.data}
 
-    errors, extensions = result.errors, result.extensions
-    data: GraphQLHTTPResponse = {
-        "data": result.data,
-        **({"errors": [err.formatted for err in errors]} if errors else {}),
-        **({"extensions": extensions} if extensions else {}),
-    }
+    if result.errors:
+        data["errors"] = [err.formatted for err in result.errors]
+    if result.extensions:
+        data["extensions"] = result.extensions
 
     return data
 
@@ -37,6 +32,7 @@ class GraphQLRequestData:
     query: Optional[str]
     variables: Optional[dict[str, Any]]
     operation_name: Optional[str]
+    extensions: Optional[dict[str, Any]]
     protocol: Literal["http", "multipart-subscription"] = "http"
 
 

{strawberry_graphql-0.269.0.dev1746905409 → strawberry_graphql-0.270.0}/strawberry/http/async_base_view.py

@@ -25,9 +25,6 @@ from strawberry.http import (
     process_result,
 )
 from strawberry.http.ides import GraphQL_IDE
-from strawberry.schema._graphql_core import (
-    GraphQLIncrementalExecutionResults,
-)
 from strawberry.schema.base import BaseSchema
 from strawberry.schema.exceptions import InvalidOperationTypeError
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
@@ -207,6 +204,7 @@ class AsyncBaseHTTPView(
                 context_value=context,
                 root_value=root_value,
                 operation_name=request_data.operation_name,
+                operation_extensions=request_data.extensions,
             )
 
         return await self.schema.execute(
@@ -216,6 +214,7 @@ class AsyncBaseHTTPView(
             context_value=context,
             operation_name=request_data.operation_name,
             allowed_operation_types=allowed_operation_types,
+            operation_extensions=request_data.extensions,
         )
 
     async def parse_multipart(self, request: AsyncHTTPRequestAdapter) -> dict[str, str]:
@@ -261,7 +260,7 @@ class AsyncBaseHTTPView(
         root_value: Optional[RootValue] = UNSET,
     ) -> WebSocketResponse: ...
 
-    async def run(  # noqa: PLR0915
+    async def run(
         self,
         request: Union[Request, WebSocketRequest],
         context: Optional[Context] = UNSET,
@@ -352,75 +351,6 @@ class AsyncBaseHTTPView(
                     "Content-Type": "multipart/mixed;boundary=graphql;subscriptionSpec=1.0,application/json",
                 },
             )
-        if isinstance(result, GraphQLIncrementalExecutionResults):
-
-            async def stream() -> AsyncGenerator[str, None]:
-                yield "---"
-
-                response = await self.process_result(request, result.initial_result)
-
-                response["hasNext"] = result.initial_result.has_next
-                response["pending"] = [
-                    p.formatted for p in result.initial_result.pending
-                ]
-                response["extensions"] = result.initial_result.extensions
-
-                yield self.encode_multipart_data(response, "-")
-
-                all_pending = result.initial_result.pending
-
-                async for value in result.subsequent_results:
-                    response = {
-                        "hasNext": value.has_next,
-                        "extensions": value.extensions,
-                    }
-
-                    if value.pending:
-                        response["pending"] = [p.formatted for p in value.pending]
-
-                    if value.completed:
-                        response["completed"] = [p.formatted for p in value.completed]
-
-                    if value.incremental:
-                        incremental = []
-
-                        all_pending.extend(value.pending)
-
-                        for incremental_value in value.incremental:
-                            pending_value = next(
-                                (
-                                    v
-                                    for v in all_pending
-                                    if v.id == incremental_value.id
-                                ),
-                                None,
-                            )
-
-                            assert pending_value
-
-                            incremental.append(
-                                {
-                                    **incremental_value.formatted,
-                                    "path": pending_value.path,
-                                    "label": pending_value.label,
-                                }
-                            )
-
-                        response["incremental"] = incremental
-
-                    yield self.encode_multipart_data(response, "-")
-
-                yield "--\r\n"
-
-            return await self.create_streaming_response(
-                request,
-                stream,
-                sub_response,
-                headers={
-                    "Transfer-Encoding": "chunked",
-                    "Content-Type": 'multipart/mixed; boundary="-"',
-                },
-            )
 
         response_data = await self.process_result(request=request, result=result)
 
@@ -432,16 +362,12 @@ class AsyncBaseHTTPView(
         )
 
     def encode_multipart_data(self, data: Any, separator: str) -> str:
-        encoded_data = self.encode_json(data)
-
         return "".join(
             [
-                "\r\n",
-                "Content-Type: application/json; charset=utf-8\r\n",
-                "Content-Length: " + str(len(encoded_data)) + "\r\n",
-                "\r\n",
-                encoded_data,
-                f"\r\n--{separator}",
+                f"\r\n--{separator}\r\n",
+                "Content-Type: application/json\r\n\r\n",
+                self.encode_json(data),
+                "\n",
             ]
         )
 
@@ -548,6 +474,7 @@ class AsyncBaseHTTPView(
             query=data.get("query"),
             variables=data.get("variables"),
             operation_name=data.get("operationName"),
+            extensions=data.get("extensions"),
             protocol=protocol,
         )
 

{strawberry_graphql-0.269.0.dev1746905409 → strawberry_graphql-0.270.0}/strawberry/http/base.py

@@ -59,6 +59,12 @@ class BaseView(Generic[Request]):
             if variables:
                 params["variables"] = self.parse_json(variables)
 
+        if "extensions" in params:
+            extensions = params["extensions"]
+
+            if extensions:
+                params["extensions"] = self.parse_json(extensions)
+
         return params
 
     @property

{strawberry_graphql-0.269.0.dev1746905409 → strawberry_graphql-0.270.0}/strawberry/http/sync_base_view.py

@@ -122,6 +122,7 @@ class SyncBaseHTTPView(
             context_value=context,
             operation_name=request_data.operation_name,
             allowed_operation_types=allowed_operation_types,
+            operation_extensions=request_data.extensions,
         )
 
     def parse_multipart(self, request: SyncHTTPRequestAdapter) -> dict[str, str]:
@@ -154,6 +155,7 @@ class SyncBaseHTTPView(
             query=data.get("query"),
             variables=data.get("variables"),
             operation_name=data.get("operationName"),
+            extensions=data.get("extensions"),
         )
 
     def _handle_errors(

{strawberry_graphql-0.269.0.dev1746905409 → strawberry_graphql-0.270.0}/strawberry/printer/printer.py

@@ -561,9 +561,9 @@ def print_schema_definition(
 def print_directive(
     directive: GraphQLDirective, *, schema: BaseSchema
 ) -> Optional[str]:
-    strawberry_directive = directive.extensions.get("strawberry-definition")
+    strawberry_directive = directive.extensions["strawberry-definition"]
 
-    if strawberry_directive is None or (
+    if (
         isinstance(strawberry_directive, StrawberrySchemaDirective)
         and not strawberry_directive.print_definition
     ):
@@ -621,14 +621,6 @@ def print_schema(schema: BaseSchema) -> str:
         if (printed_directive := print_directive(directive, schema=schema)) is not None
     ]
 
-    if schema.config.enable_experimental_incremental_execution:
-        directives.append(
-            "directive @defer(if: Boolean, label: String) on FRAGMENT_SPREAD | INLINE_FRAGMENT"
-        )
-        directives.append(
-            "directive @stream(if: Boolean, label: String, initialCount: Int = 0) on FIELD"
-        )
-
     def _name_getter(type_: Any) -> str:
         if hasattr(type_, "name"):
             return type_.name

strawberry_graphql-0.270.0/strawberry/quart/views.py

@@ -0,0 +1,216 @@
+import asyncio
+import warnings
+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, Websocket, request, websocket
+from quart.ctx import has_websocket_context
+from quart.views import View
+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
+    from strawberry.http import GraphQLHTTPResponse
+    from strawberry.schema.base import BaseSchema
+
+
+class QuartHTTPRequestAdapter(AsyncHTTPRequestAdapter):
+    def __init__(self, request: Request) -> None:
+        self.request = request
+
+    @property
+    def query_params(self) -> QueryParams:
+        return self.request.args.to_dict()
+
+    @property
+    def method(self) -> HTTPMethod:
+        return cast("HTTPMethod", self.request.method.upper())
+
+    @property
+    def content_type(self) -> Optional[str]:
+        return self.request.content_type
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        return self.request.headers  # type: ignore
+
+    async def get_body(self) -> str:
+        return (await self.request.data).decode()
+
+    async def get_form_data(self) -> FormData:
+        files = await self.request.files
+        form = await self.request.form
+        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, 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,
+        schema: "BaseSchema",
+        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:
+            warnings.warn(
+                "The `graphiql` argument is deprecated in favor of `graphql_ide`",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            self.graphql_ide = "graphiql" if graphiql else None
+        else:
+            self.graphql_ide = graphql_ide
+
+    async def render_graphql_ide(self, request: Request) -> Response:
+        return Response(self.graphql_ide_html)
+
+    def create_response(
+        self, response_data: "GraphQLHTTPResponse", sub_response: Response
+    ) -> Response:
+        sub_response.set_data(self.encode_json(response_data))
+
+        return sub_response
+
+    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: 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, **kwargs: object) -> "ResponseReturnValue":
+        try:
+            return await self.run(
+                request=websocket if has_websocket_context() else request
+            )
+        except HTTPException as e:
+            return Response(
+                response=e.reason,
+                status=e.status_code,
+            )
+
+    async def create_streaming_response(
+        self,
+        request: Request,
+        stream: Callable[[], AsyncGenerator[str, None]],
+        sub_response: Response,
+        headers: dict[str, str],
+    ) -> Response:
+        return (
+            stream(),
+            sub_response.status_code,
+            {  # type: ignore
+                **sub_response.headers,
+                **headers,
+            },
+        )
+
+    def is_websocket_request(
+        self, request: Union[Request, Websocket]
+    ) -> TypeGuard[Websocket]:
+        return has_websocket_context()
+
+    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: Websocket, subprotocol: Optional[str]
+    ) -> Response:
+        await request.accept(subprotocol=subprotocol)
+        return Response()
+
+
+__all__ = ["GraphQLView"]

{strawberry_graphql-0.269.0.dev1746905409 → strawberry_graphql-0.270.0}/strawberry/schema/base.py

@@ -47,6 +47,7 @@ class BaseSchema(Protocol):
         root_value: Optional[Any] = None,
         operation_name: Optional[str] = None,
         allowed_operation_types: Optional[Iterable[OperationType]] = None,
+        operation_extensions: Optional[dict[str, Any]] = None,
     ) -> ExecutionResult:
         raise NotImplementedError
 
@@ -59,6 +60,7 @@ class BaseSchema(Protocol):
         root_value: Optional[Any] = None,
         operation_name: Optional[str] = None,
         allowed_operation_types: Optional[Iterable[OperationType]] = None,
+        operation_extensions: Optional[dict[str, Any]] = None,
     ) -> ExecutionResult:
         raise NotImplementedError
 
@@ -70,6 +72,7 @@ class BaseSchema(Protocol):
         context_value: Optional[Any] = None,
         root_value: Optional[Any] = None,
         operation_name: Optional[str] = None,
+        operation_extensions: Optional[dict[str, Any]] = None,
     ) -> SubscriptionResult:
         raise NotImplementedError
 

{strawberry_graphql-0.269.0.dev1746905409 → strawberry_graphql-0.270.0}/strawberry/schema/config.py

@@ -17,7 +17,6 @@ class StrawberryConfig:
     relay_use_legacy_global_id: bool = False
     disable_field_suggestions: bool = False
     info_class: type[Info] = Info
-    enable_experimental_incremental_execution: bool = False
 
     def __post_init__(
         self,