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

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

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

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

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

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

@@ -11,6 +11,7 @@ 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
@@ -37,6 +38,7 @@ __all__ = [
     "Private",
     "Schema",
     "Some",
+    "Streamable",
     "argument",
     "asdict",
     "auto",

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

@@ -17,6 +17,7 @@ from typing import (
 )
 from typing_extensions import Self, get_args, get_origin
 
+from strawberry.streamable import StrawberryStreamable
 from strawberry.types.base import (
     StrawberryList,
     StrawberryMaybe,
@@ -143,6 +144,8 @@ 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):
@@ -323,6 +326,10 @@ 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.268.0 → strawberry_graphql-0.269.0.dev1746905409}/strawberry/http/__init__.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Optional
+from typing import Any, Optional
 from typing_extensions import Literal, TypedDict
 
-if TYPE_CHECKING:
-    from strawberry.types import ExecutionResult
+from strawberry.schema._graphql_core import (
+    GraphQLIncrementalExecutionResults,
+    ResultType,
+)
 
 
 class GraphQLHTTPResponse(TypedDict, total=False):
@@ -14,13 +16,16 @@ class GraphQLHTTPResponse(TypedDict, total=False):
     extensions: Optional[dict[str, object]]
 
 
-def process_result(result: ExecutionResult) -> GraphQLHTTPResponse:
-    data: GraphQLHTTPResponse = {"data": result.data}
+def process_result(result: ResultType) -> GraphQLHTTPResponse:
+    if isinstance(result, GraphQLIncrementalExecutionResults):
+        return result
 
-    if result.errors:
-        data["errors"] = [err.formatted for err in result.errors]
-    if result.extensions:
-        data["extensions"] = result.extensions
+    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 {}),
+    }
 
     return data
 

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

@@ -25,6 +25,9 @@ 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
@@ -258,7 +261,7 @@ class AsyncBaseHTTPView(
         root_value: Optional[RootValue] = UNSET,
     ) -> WebSocketResponse: ...
 
-    async def run(
+    async def run(  # noqa: PLR0915
         self,
         request: Union[Request, WebSocketRequest],
         context: Optional[Context] = UNSET,
@@ -349,6 +352,75 @@ 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)
 
@@ -360,12 +432,16 @@ class AsyncBaseHTTPView(
         )
 
     def encode_multipart_data(self, data: Any, separator: str) -> str:
+        encoded_data = self.encode_json(data)
+
         return "".join(
             [
-                f"\r\n--{separator}\r\n",
-                "Content-Type: application/json\r\n\r\n",
-                self.encode_json(data),
-                "\n",
+                "\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}",
             ]
         )
 

{strawberry_graphql-0.268.0 → strawberry_graphql-0.269.0.dev1746905409}/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["strawberry-definition"]
+    strawberry_directive = directive.extensions.get("strawberry-definition")
 
-    if (
+    if strawberry_directive is None or (
         isinstance(strawberry_directive, StrawberrySchemaDirective)
         and not strawberry_directive.print_definition
     ):
@@ -621,6 +621,14 @@ 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.269.0.dev1746905409/strawberry/schema/_graphql_core.py

@@ -0,0 +1,46 @@
+from typing import Union
+
+from graphql.execution import ExecutionContext as GraphQLExecutionContext
+from graphql.execution import ExecutionResult as GraphQLExecutionResult
+from graphql.execution import execute, subscribe
+
+from strawberry.types import ExecutionResult
+
+try:
+    from graphql import (
+        ExperimentalIncrementalExecutionResults as GraphQLIncrementalExecutionResults,
+    )
+    from graphql.execution import experimental_execute_incrementally
+    from graphql.type.directives import (
+        GraphQLDeferDirective,
+        GraphQLStreamDirective,
+    )
+
+    incremental_execution_directives = (
+        GraphQLDeferDirective,
+        GraphQLStreamDirective,
+    )
+
+except ImportError:
+    GraphQLIncrementalExecutionResults = type(None)
+
+    incremental_execution_directives = []
+    experimental_execute_incrementally = None
+
+
+# TODO: give this a better name, maybe also a better place
+ResultType = Union[
+    GraphQLExecutionResult,
+    GraphQLIncrementalExecutionResults,
+    ExecutionResult,
+]
+
+__all__ = [
+    "GraphQLExecutionContext",
+    "GraphQLIncrementalExecutionResults",
+    "ResultType",
+    "execute",
+    "experimental_execute_incrementally",
+    "incremental_execution_directives",
+    "subscribe",
+]

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

@@ -17,6 +17,7 @@ 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,

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

@@ -29,8 +29,6 @@ from graphql import (
     parse,
     validate_schema,
 )
-from graphql.execution import ExecutionContext as GraphQLExecutionContext
-from graphql.execution import execute, subscribe
 from graphql.execution.middleware import MiddlewareManager
 from graphql.type.directives import specified_directives
 from graphql.validation import validate
@@ -63,6 +61,15 @@ from strawberry.utils.aio import aclosing
 from strawberry.utils.await_maybe import await_maybe
 
 from . import compat
+from ._graphql_core import (
+    GraphQLExecutionContext,
+    GraphQLIncrementalExecutionResults,
+    ResultType,
+    execute,
+    experimental_execute_incrementally,
+    incremental_execution_directives,
+    subscribe,
+)
 from .base import BaseSchema
 from .config import StrawberryConfig
 from .exceptions import InvalidOperationTypeError
@@ -91,6 +98,7 @@ OriginSubscriptionResult = Union[
     AsyncIterator[OriginalExecutionResult],
 ]
 
+
 DEFAULT_ALLOWED_OPERATION_TYPES = {
     OperationType.QUERY,
     OperationType.MUTATION,
@@ -255,11 +263,16 @@ class Schema(BaseSchema):
                 graphql_types.append(graphql_type)
 
         try:
+            directives = specified_directives + tuple(graphql_directives)
+
+            if self.config.enable_experimental_incremental_execution:
+                directives = tuple(directives) + tuple(incremental_execution_directives)
+
             self._schema = GraphQLSchema(
                 query=query_type,
                 mutation=mutation_type,
                 subscription=subscription_type if subscription else None,
-                directives=specified_directives + tuple(graphql_directives),
+                directives=directives,
                 types=graphql_types,
                 extensions={
                     GraphQLCoreConverter.DEFINITION_BACKREF: self,
@@ -437,12 +450,16 @@ class Schema(BaseSchema):
     async def _handle_execution_result(
         self,
         context: ExecutionContext,
-        result: Union[GraphQLExecutionResult, ExecutionResult],
+        result: ResultType,
         extensions_runner: SchemaExtensionsRunner,
         *,
         # TODO: can we remove this somehow, see comment in execute
         skip_process_errors: bool = False,
     ) -> ExecutionResult:
+        # TODO: handle this, also, why do we have both GraphQLExecutionResult and ExecutionResult?
+        if isinstance(result, GraphQLIncrementalExecutionResults):
+            return result
+
         # Set errors on the context so that it's easier
         # to access in extensions
         if result.errors:
@@ -483,6 +500,17 @@ class Schema(BaseSchema):
         extensions_runner = self.create_extensions_runner(execution_context, extensions)
         middleware_manager = self._get_middleware_manager(extensions)
 
+        execute_function = execute
+
+        if self.config.enable_experimental_incremental_execution:
+            execute_function = experimental_execute_incrementally
+
+            if execute_function is None:
+                raise RuntimeError(
+                    "Incremental execution is enabled but experimental_execute_incrementally is not available, "
+                    "please install graphql-core>=3.3.0"
+                )
+
         try:
             async with extensions_runner.operation():
                 # Note: In graphql-core the schema would be validated here but in
@@ -501,7 +529,7 @@ class Schema(BaseSchema):
                 async with extensions_runner.executing():
                     if not execution_context.result:
                         result = await await_maybe(
-                            execute(
+                            execute_function(
                                 self._schema,
                                 execution_context.graphql_document,
                                 root_value=execution_context.root_value,
@@ -517,7 +545,9 @@ class Schema(BaseSchema):
                         result = execution_context.result
                     # Also set errors on the execution_context so that it's easier
                     # to access in extensions
-                    if result.errors:
+
+                    # TODO: maybe here use the first result from incremental execution if it exists
+                    if isinstance(result, GraphQLExecutionResult) and result.errors:
                         execution_context.errors = result.errors
 
                         # Run the `Schema.process_errors` function here before
@@ -567,6 +597,16 @@ class Schema(BaseSchema):
         extensions_runner = self.create_extensions_runner(execution_context, extensions)
         middleware_manager = self._get_middleware_manager(extensions)
 
+        execute_function = execute
+
+        if self.config.enable_experimental_incremental_execution:
+            execute_function = experimental_execute_incrementally
+
+            if execute_function is None:
+                raise RuntimeError(
+                    "Incremental execution is enabled but experimental_execute_incrementally is not available, "
+                    "please install graphql-core>=3.3.0"
+                )
         try:
             with extensions_runner.operation():
                 # Note: In graphql-core the schema would be validated here but in
@@ -608,7 +648,7 @@ class Schema(BaseSchema):
 
                 with extensions_runner.executing():
                     if not execution_context.result:
-                        result = execute(
+                        result = execute_function(
                             self._schema,
                             execution_context.graphql_document,
                             root_value=execution_context.root_value,

{strawberry_graphql-0.268.0 → strawberry_graphql-0.269.0.dev1746905409}/strawberry/static/graphiql.html

@@ -1,4 +1,4 @@
-<!DOCTYPE html>
+<!doctype html>
 <html>
   <head>
     <title>Strawberry GraphiQL</title>
@@ -61,8 +61,8 @@
     <link
       crossorigin
       rel="stylesheet"
-      href="https://unpkg.com/graphiql@3.0.9/graphiql.min.css"
-      integrity="sha384-yz3/sqpuplkA7msMo0FE4ekg0xdwdvZ8JX9MVZREsxipqjU4h8IRfmAMRcb1QpUy"
+      href="https://unpkg.com/graphiql@3.8.3/graphiql.min.css"
+      integrity="sha384-Mq3vbRBY71jfjQAt/DcjxUIYY33ksal4cgdRt9U/hNPvHBCaT2JfJ/PTRiPKf0aM"
     />
 
     <link
@@ -77,8 +77,8 @@
     <div id="graphiql" class="graphiql-container">Loading...</div>
     <script
       crossorigin
-      src="https://unpkg.com/graphiql@3.0.9/graphiql.min.js"
-      integrity="sha384-Mjte+vxCWz1ZYCzszGHiJqJa5eAxiqI4mc3BErq7eDXnt+UGLXSEW7+i0wmfPiji"
+      src="https://unpkg.com/graphiql@3.8.3/graphiql.min.js"
+      integrity="sha384-HbRVEFG0JGJZeAHCJ9Xm2+tpknBQ7QZmNlO/DgZtkZ0aJSypT96YYGRNod99l9Ie"
     ></script>
     <script
       crossorigin

strawberry_graphql-0.269.0.dev1746905409/strawberry/streamable.py

@@ -0,0 +1,36 @@
+from collections.abc import AsyncGenerator
+from typing import Annotated, TypeVar
+
+
+class StrawberryStreamable: ...
+
+
+T = TypeVar("T")
+
+Streamable = Annotated[AsyncGenerator[T, None], StrawberryStreamable()]
+"""Represents a list that can be streamed using @stream.
+
+Example:
+
+```python
+import strawberry
+from dataclasses import dataclass
+
+
+@strawberry.type
+class Comment:
+    id: strawberry.ID
+    content: str
+
+
+@strawberry.type
+class Article:
+    @strawberry.field
+    @staticmethod
+    async def comments() -> strawberry.Streamable[Comment]:
+        for comment in fetch_comments():
+            yield comment
+```
+"""
+
+__all__ = ["Streamable"]