strawberry-graphql 0.276.0.dev1750672223__tar.gz → 0.276.1__tar.gz

{strawberry_graphql-0.276.0.dev1750672223 → strawberry_graphql-0.276.1}/PKG-INFO

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

{strawberry_graphql-0.276.0.dev1750672223 → strawberry_graphql-0.276.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "strawberry-graphql"
-version = "0.276.0.dev.1750672223"
+version = "0.276.1"
 description = "A library for creating GraphQL APIs"
 authors = [{ name = "Patrick Arminio", email = "patrick.arminio@gmail.com" }]
 license = { text = "MIT" }
@@ -67,7 +67,7 @@ packages = [{ include = "strawberry" }]
 include = ["strawberry/py.typed"]
 
 [tool.poetry.group.dev.dependencies]
-ruff = "^0.11.4"
+ruff = "^0.12.3"
 asgiref = "^3.2"
 email-validator = { version = ">=1.1.3,<3.0.0", optional = false }
 freezegun = "^1.2.1"
@@ -220,6 +220,7 @@ ignore = [
   # after we drop support for Python 3.9
   "UP006",
   "UP007",
+  "UP045",
 
   # we use asserts in tests and to hint mypy
   "S101",
@@ -308,6 +309,9 @@ ignore = [
   # Don't force if branches to be converted to "or"
   "SIM114",
 
+  # Allow imports inside functions
+  "PLC0415",
+
   # ruff formatter recommends to disable those, as they conflict with it
   # we don't need to ever enable those.
   "COM812",
@@ -324,6 +328,7 @@ ignore = [
   "Q003",
   "W191",
 ]
+exclude = ["tests/python_312/*"] # SyntaxError because we support Python 3.9+
 
 [tool.ruff.lint.per-file-ignores]
 ".github/*" = ["INP001"]

{strawberry_graphql-0.276.0.dev1750672223 → strawberry_graphql-0.276.1}/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.276.0.dev1750672223 → strawberry_graphql-0.276.1}/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 self._is_maybe(evaled_type):
@@ -335,10 +332,6 @@ class StrawberryAnnotation:
     def _is_maybe(cls, annotation: Any) -> bool:
         return _annotation_is_maybe(annotation)
 
-    @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.276.0.dev1750672223 → strawberry_graphql-0.276.1}/strawberry/cli/__init__.py

@@ -1,15 +1,15 @@
 try:
     from .app import app
-    from .commands.codegen import codegen as codegen  # noqa: PLC0414
-    from .commands.export_schema import export_schema as export_schema  # noqa: PLC0414
+    from .commands.codegen import codegen as codegen
+    from .commands.export_schema import export_schema as export_schema
     from .commands.locate_definition import (
-        locate_definition as locate_definition,  # noqa: PLC0414
+        locate_definition as locate_definition,
     )
     from .commands.schema_codegen import (
-        schema_codegen as schema_codegen,  # noqa: PLC0414
+        schema_codegen as schema_codegen,
     )
-    from .commands.server import server as server  # noqa: PLC0414
-    from .commands.upgrade import upgrade as upgrade  # noqa: PLC0414
+    from .commands.server import server as server
+    from .commands.upgrade import upgrade as upgrade
 
     def run() -> None:
         app()

{strawberry_graphql-0.276.0.dev1750672223 → strawberry_graphql-0.276.1}/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
 

{strawberry_graphql-0.276.0.dev1750672223 → strawberry_graphql-0.276.1}/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 (
     CannotGetOperationTypeError,
@@ -201,8 +198,6 @@ class AsyncBaseHTTPView(
         if not self.allow_queries_via_get and request_adapter.method == "GET":
             allowed_operation_types = allowed_operation_types - {OperationType.QUERY}
 
-        assert self.schema
-
         if request_data.protocol == "multipart-subscription":
             return await self.schema.subscribe(
                 request_data.query,  # type: ignore
@@ -266,7 +261,7 @@ class AsyncBaseHTTPView(
         root_value: Optional[RootValue] = UNSET,
     ) -> WebSocketResponse: ...
 
-    async def run(  # noqa: PLR0915
+    async def run(
         self,
         request: Union[Request, WebSocketRequest],
         context: Context = UNSET,
@@ -294,7 +289,7 @@ class AsyncBaseHTTPView(
                     view=self,
                     websocket=websocket,
                     context=context,
-                    root_value=root_value,  # type: ignore
+                    root_value=root_value,
                     schema=self.schema,
                     debug=self.debug,
                     connection_init_wait_timeout=self.connection_init_wait_timeout,
@@ -304,7 +299,7 @@ class AsyncBaseHTTPView(
                     view=self,
                     websocket=websocket,
                     context=context,
-                    root_value=root_value,  # type: ignore
+                    root_value=root_value,
                     schema=self.schema,
                     debug=self.debug,
                     keep_alive=self.keep_alive,
@@ -357,75 +352,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)
 
@@ -437,16 +363,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",
             ]
         )
 
@@ -605,11 +527,32 @@ class AsyncBaseHTTPView(
         else:
             raise HTTPException(400, "Unsupported content type")
 
+        query = data.get("query")
+        if not isinstance(query, (str, type(None))):
+            raise HTTPException(
+                400,
+                "The GraphQL operation's `query` must be a string or null, if provided.",
+            )
+
+        variables = data.get("variables")
+        if not isinstance(variables, (dict, type(None))):
+            raise HTTPException(
+                400,
+                "The GraphQL operation's `variables` must be an object or null, if provided.",
+            )
+
+        extensions = data.get("extensions")
+        if not isinstance(extensions, (dict, type(None))):
+            raise HTTPException(
+                400,
+                "The GraphQL operation's `extensions` must be an object or null, if provided.",
+            )
+
         return GraphQLRequestData(
-            query=data.get("query"),
-            variables=data.get("variables"),
+            query=query,
+            variables=variables,
             operation_name=data.get("operationName"),
-            extensions=data.get("extensions"),
+            extensions=extensions,
             protocol=protocol,
         )
 

{strawberry_graphql-0.276.0.dev1750672223 → strawberry_graphql-0.276.1}/strawberry/http/sync_base_view.py

@@ -116,8 +116,6 @@ class SyncBaseHTTPView(
         if not self.allow_queries_via_get and request_adapter.method == "GET":
             allowed_operation_types = allowed_operation_types - {OperationType.QUERY}
 
-        assert self.schema
-
         return self.schema.execute_sync(
             request_data.query,
             root_value=root_value,
@@ -154,11 +152,32 @@ class SyncBaseHTTPView(
         else:
             raise HTTPException(400, "Unsupported content type")
 
+        query = data.get("query")
+        if not isinstance(query, (str, type(None))):
+            raise HTTPException(
+                400,
+                "The GraphQL operation's `query` must be a string or null, if provided.",
+            )
+
+        variables = data.get("variables")
+        if not isinstance(variables, (dict, type(None))):
+            raise HTTPException(
+                400,
+                "The GraphQL operation's `variables` must be an object or null, if provided.",
+            )
+
+        extensions = data.get("extensions")
+        if not isinstance(extensions, (dict, type(None))):
+            raise HTTPException(
+                400,
+                "The GraphQL operation's `extensions` must be an object or null, if provided.",
+            )
+
         return GraphQLRequestData(
-            query=data.get("query"),
-            variables=data.get("variables"),
+            query=query,
+            variables=variables,
             operation_name=data.get("operationName"),
-            extensions=data.get("extensions"),
+            extensions=extensions,
         )
 
     def _handle_errors(

{strawberry_graphql-0.276.0.dev1750672223 → strawberry_graphql-0.276.1}/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.276.0.dev1750672223 → strawberry_graphql-0.276.1}/strawberry/relay/fields.py

@@ -261,7 +261,12 @@ class ConnectionExtension(FieldExtension):
         if isinstance(f_type, StrawberryOptional):
             f_type = f_type.of_type
 
+        if isinstance(f_type, LazyType):
+            f_type = f_type.resolve_type()
+
         type_origin = get_origin(f_type) if is_generic_alias(f_type) else f_type
+        if isinstance(type_origin, LazyType):
+            type_origin = type_origin.resolve_type()
 
         if not isinstance(type_origin, type) or not issubclass(type_origin, Connection):
             raise RelayWrongAnnotationError(field.name, cast("type", field.origin))

{strawberry_graphql-0.276.0.dev1750672223 → strawberry_graphql-0.276.1}/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
     _unsafe_disable_same_type_validation: bool = False
 
     def __post_init__(

{strawberry_graphql-0.276.0.dev1750672223 → strawberry_graphql-0.276.1}/strawberry/schema/name_converter.py

@@ -150,8 +150,9 @@ class NameConverter:
         type_ = eval_type(type_)
 
         if isinstance(type_, LazyType):
-            name = type_.type_name
-        elif isinstance(type_, EnumDefinition):
+            type_ = type_.resolve_type()
+
+        if isinstance(type_, EnumDefinition):
             name = type_.name
         elif isinstance(type_, StrawberryUnion):
             name = type_.graphql_name if type_.graphql_name else self.from_union(type_)

{strawberry_graphql-0.276.0.dev1750672223 → strawberry_graphql-0.276.1}/strawberry/schema/schema.py

@@ -15,6 +15,7 @@ from typing import (
     cast,
 )
 
+from graphql import ExecutionContext as GraphQLExecutionContext
 from graphql import ExecutionResult as GraphQLExecutionResult
 from graphql import (
     ExecutionResult as OriginalExecutionResult,
@@ -35,6 +36,7 @@ from graphql import (
     parse,
     validate_schema,
 )
+from graphql.execution import execute, subscribe
 from graphql.execution.middleware import MiddlewareManager
 from graphql.type.directives import specified_directives
 from graphql.validation import validate
@@ -67,15 +69,6 @@ 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 CannotGetOperationTypeError, InvalidOperationTypeError
@@ -106,7 +99,6 @@ OriginSubscriptionResult = Union[
     AsyncIterator[OriginalExecutionResult],
 ]
 
-
 DEFAULT_ALLOWED_OPERATION_TYPES = {
     OperationType.QUERY,
     OperationType.MUTATION,
@@ -329,16 +321,11 @@ 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=directives,
+                directives=specified_directives + tuple(graphql_directives),
                 types=graphql_types,
                 extensions={
                     GraphQLCoreConverter.DEFINITION_BACKREF: self,
@@ -531,16 +518,12 @@ class Schema(BaseSchema):
     async def _handle_execution_result(
         self,
         context: ExecutionContext,
-        result: ResultType,
+        result: Union[GraphQLExecutionResult, ExecutionResult],
         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:
@@ -583,17 +566,6 @@ 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"
-                )
-
         custom_context_kwargs = self._get_custom_context_kwargs(operation_extensions)
 
         try:
@@ -614,7 +586,7 @@ class Schema(BaseSchema):
                 async with extensions_runner.executing():
                     if not execution_context.result:
                         result = await await_maybe(
-                            execute_function(
+                            execute(
                                 self._schema,
                                 execution_context.graphql_document,
                                 root_value=execution_context.root_value,
@@ -631,9 +603,7 @@ class Schema(BaseSchema):
                         result = execution_context.result
                     # Also set errors on the execution_context so that it's easier
                     # to access in extensions
-
-                    # TODO: maybe here use the first result from incremental execution if it exists
-                    if isinstance(result, GraphQLExecutionResult) and result.errors:
+                    if result.errors:
                         execution_context.errors = result.errors
 
                         # Run the `Schema.process_errors` function here before
@@ -689,16 +659,6 @@ 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"
-                )
         custom_context_kwargs = self._get_custom_context_kwargs(operation_extensions)
 
         try:
@@ -749,7 +709,7 @@ class Schema(BaseSchema):
 
                 with extensions_runner.executing():
                     if not execution_context.result:
-                        result = execute_function(
+                        result = execute(
                             self._schema,
                             execution_context.graphql_document,
                             root_value=execution_context.root_value,