strawberry-graphql 0.275.7__py3-none-any.whl → 0.284.3__py3-none-any.whl

strawberry/relay/utils.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 import base64
 import dataclasses
 import sys
-from typing import TYPE_CHECKING, Any, Union
+from typing import TYPE_CHECKING, Any
 from typing_extensions import Self, assert_never
 
 from strawberry.types.base import StrawberryObjectDefinition
-from strawberry.types.nodes import InlineFragment, Selection
+from strawberry.types.nodes import InlineFragment
 
 if TYPE_CHECKING:
     from strawberry.types.info import Info
@@ -39,7 +39,7 @@ def from_base64(value: str) -> tuple[str, str]:
     return res[0], res[1]
 
 
-def to_base64(type_: Union[str, type, StrawberryObjectDefinition], node_id: Any) -> str:
+def to_base64(type_: str | type | StrawberryObjectDefinition, node_id: Any) -> str:
     """Encode the type name and node id to a base64 string.
 
     Args:
@@ -83,31 +83,19 @@ def should_resolve_list_connection_edges(info: Info) -> bool:
 
     """
     resolve_for_field_names = {"edges", "pageInfo"}
-
-    def _check_selection(selection: Selection) -> bool:
-        """Recursively inspect the selection to check if the user requested to resolve the `edges` field.
-
-        Args:
-            selection (Selection): The selection to check.
-
-        Returns:
-            bool: True if the user requested to resolve the `edges` field of a connection, False otherwise.
-        """
+    # Recursively inspect the selection to check if the user requested to resolve the `edges` field.
+    stack = []
+    for selection_field in info.selected_fields:
+        stack.extend(selection_field.selections)
+    while stack:
+        selection = stack.pop()
         if (
             not isinstance(selection, InlineFragment)
             and selection.name in resolve_for_field_names
         ):
             return True
-        if selection.selections:
-            return any(
-                _check_selection(selection) for selection in selection.selections
-            )
-        return False
-
-    for selection_field in info.selected_fields:
-        for selection in selection_field.selections:
-            if _check_selection(selection):
-                return True
+        if nested_selections := getattr(selection, "selections", None):
+            stack.extend(nested_selections)
     return False
 
 

strawberry/resolvers.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 
 def is_default_resolver(func: Callable[..., Any]) -> bool:

strawberry/sanic/context.py

@@ -2,6 +2,7 @@ import warnings
 from typing_extensions import TypedDict
 
 from sanic.request import Request
+
 from strawberry.http.temporal_response import TemporalResponse
 
 

strawberry/sanic/utils.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, cast
 
 if TYPE_CHECKING:
     from sanic.request import File, Request
@@ -21,12 +21,12 @@ def convert_request_to_files_dict(request: Request) -> dict[str, Any]:
 
     Note that the dictionary entries are lists.
     """
-    request_files = cast("Optional[dict[str, list[File]]]", request.files)
+    request_files = cast("dict[str, list[File]] | None", request.files)
 
     if not request_files:
         return {}
 
-    files_dict: dict[str, Union[File, list[File]]] = {}
+    files_dict: dict[str, File | list[File]] = {}
 
     for field_name, file_list in request_files.items():
         assert len(file_list) == 1

strawberry/sanic/views.py

@@ -5,70 +5,29 @@ import warnings
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Optional,
-    cast,
+    TypeGuard,
 )
-from typing_extensions import TypeGuard
 
+from lia import HTTPException, SanicHTTPRequestAdapter
 from sanic.request import Request
 from sanic.response import HTTPResponse, html
 from sanic.views import HTTPMethodView
-from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncHTTPRequestAdapter
-from strawberry.http.exceptions import HTTPException
+
+from strawberry.http.async_base_view import AsyncBaseHTTPView
 from strawberry.http.temporal_response import TemporalResponse
-from strawberry.http.types import FormData, HTTPMethod, QueryParams
 from strawberry.http.typevars import (
     Context,
     RootValue,
 )
-from strawberry.sanic.utils import convert_request_to_files_dict
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncGenerator, Mapping
+    from collections.abc import AsyncGenerator, Callable
 
     from strawberry.http import GraphQLHTTPResponse
     from strawberry.http.ides import GraphQL_IDE
     from strawberry.schema import BaseSchema
 
 
-class SanicHTTPRequestAdapter(AsyncHTTPRequestAdapter):
-    def __init__(self, request: Request) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        # Just a heads up, Sanic's request.args uses urllib.parse.parse_qs
-        # to parse query string parameters. This returns a dictionary where
-        # the keys are the unique variable names and the values are lists
-        # of values for each variable name. To ensure consistency, we're
-        # enforcing the use of the first value in each list.
-        args = self.request.get_args(keep_blank_values=True)
-        return {k: args.get(k, None) for k in args}
-
-    @property
-    def method(self) -> HTTPMethod:
-        return cast("HTTPMethod", self.request.method.upper())
-
-    @property
-    def headers(self) -> Mapping[str, str]:
-        return self.request.headers
-
-    @property
-    def content_type(self) -> Optional[str]:
-        return self.request.content_type
-
-    async def get_body(self) -> str:
-        return self.request.body.decode()
-
-    async def get_form_data(self) -> FormData:
-        assert self.request.form is not None
-
-        files = convert_request_to_files_dict(self.request)
-
-        return FormData(form=self.request.form, files=files)
-
-
 class GraphQLView(
     AsyncBaseHTTPView[
         Request,
@@ -104,11 +63,11 @@ class GraphQLView(
     def __init__(
         self,
         schema: BaseSchema,
-        graphiql: Optional[bool] = None,
-        graphql_ide: Optional[GraphQL_IDE] = "graphiql",
+        graphiql: bool | None = None,
+        graphql_ide: GraphQL_IDE | None = "graphiql",
         allow_queries_via_get: bool = True,
-        json_encoder: Optional[type[json.JSONEncoder]] = None,
-        json_dumps_params: Optional[dict[str, Any]] = None,
+        json_encoder: type[json.JSONEncoder] | None = None,
+        json_dumps_params: dict[str, Any] | None = None,
         multipart_uploads_enabled: bool = False,
     ) -> None:
         self.schema = schema
@@ -143,7 +102,7 @@ class GraphQLView(
         else:
             self.graphql_ide = graphql_ide
 
-    async def get_root_value(self, request: Request) -> Optional[RootValue]:
+    async def get_root_value(self, request: Request) -> RootValue | None:
         return None
 
     async def get_context(
@@ -158,7 +117,9 @@ class GraphQLView(
         return TemporalResponse()
 
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: TemporalResponse
+        self,
+        response_data: GraphQLHTTPResponse | list[GraphQLHTTPResponse],
+        sub_response: TemporalResponse,
     ) -> HTTPResponse:
         status_code = sub_response.status_code
 
@@ -216,11 +177,11 @@ class GraphQLView(
     def is_websocket_request(self, request: Request) -> TypeGuard[Request]:
         return False
 
-    async def pick_websocket_subprotocol(self, request: Request) -> Optional[str]:
+    async def pick_websocket_subprotocol(self, request: Request) -> str | None:
         raise NotImplementedError
 
     async def create_websocket_response(
-        self, request: Request, subprotocol: Optional[str]
+        self, request: Request, subprotocol: str | None
     ) -> TemporalResponse:
         raise NotImplementedError
 

strawberry/scalars.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import base64
-from typing import TYPE_CHECKING, Any, NewType, Union
+from typing import TYPE_CHECKING, Any, NewType
 
 from strawberry.types.scalar import scalar
 
@@ -59,7 +59,7 @@ Base64 = scalar(
 
 def is_scalar(
     annotation: Any,
-    scalar_registry: Mapping[object, Union[ScalarWrapper, ScalarDefinition]],
+    scalar_registry: Mapping[object, ScalarWrapper | ScalarDefinition],
 ) -> bool:
     if annotation in scalar_registry:
         return True

strawberry/schema/_graphql_core.py

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

strawberry/schema/base.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 from typing_extensions import Protocol
 
 from strawberry.utils.logging import StrawberryLogger
@@ -34,33 +34,33 @@ class BaseSchema(Protocol):
     config: StrawberryConfig
     schema_converter: GraphQLCoreConverter
     query: type[WithStrawberryObjectDefinition]
-    mutation: Optional[type[WithStrawberryObjectDefinition]]
-    subscription: Optional[type[WithStrawberryObjectDefinition]]
+    mutation: type[WithStrawberryObjectDefinition] | None
+    subscription: type[WithStrawberryObjectDefinition] | None
     schema_directives: list[object]
 
     @abstractmethod
     async def execute(
         self,
-        query: Optional[str],
-        variable_values: Optional[dict[str, Any]] = None,
-        context_value: Optional[Any] = None,
-        root_value: Optional[Any] = None,
-        operation_name: Optional[str] = None,
-        allowed_operation_types: Optional[Iterable[OperationType]] = None,
-        operation_extensions: Optional[dict[str, Any]] = None,
+        query: str | None,
+        variable_values: dict[str, Any] | None = None,
+        context_value: Any | None = None,
+        root_value: Any | None = None,
+        operation_name: str | None = None,
+        allowed_operation_types: Iterable[OperationType] | None = None,
+        operation_extensions: dict[str, Any] | None = None,
     ) -> ExecutionResult:
         raise NotImplementedError
 
     @abstractmethod
     def execute_sync(
         self,
-        query: Optional[str],
-        variable_values: Optional[dict[str, Any]] = None,
-        context_value: Optional[Any] = None,
-        root_value: Optional[Any] = None,
-        operation_name: Optional[str] = None,
-        allowed_operation_types: Optional[Iterable[OperationType]] = None,
-        operation_extensions: Optional[dict[str, Any]] = None,
+        query: str | None,
+        variable_values: dict[str, Any] | None = None,
+        context_value: Any | None = None,
+        root_value: Any | None = None,
+        operation_name: str | None = None,
+        allowed_operation_types: Iterable[OperationType] | None = None,
+        operation_extensions: dict[str, Any] | None = None,
     ) -> ExecutionResult:
         raise NotImplementedError
 
@@ -68,29 +68,28 @@ class BaseSchema(Protocol):
     async def subscribe(
         self,
         query: str,
-        variable_values: Optional[dict[str, Any]] = None,
-        context_value: Optional[Any] = None,
-        root_value: Optional[Any] = None,
-        operation_name: Optional[str] = None,
-        operation_extensions: Optional[dict[str, Any]] = None,
+        variable_values: dict[str, Any] | None = None,
+        context_value: Any | None = None,
+        root_value: Any | None = None,
+        operation_name: str | None = None,
+        operation_extensions: dict[str, Any] | None = None,
     ) -> SubscriptionResult:
         raise NotImplementedError
 
     @abstractmethod
     def get_type_by_name(
         self, name: str
-    ) -> Optional[
-        Union[
-            StrawberryObjectDefinition,
-            ScalarDefinition,
-            EnumDefinition,
-            StrawberryUnion,
-        ]
-    ]:
+    ) -> (
+        StrawberryObjectDefinition
+        | ScalarDefinition
+        | EnumDefinition
+        | StrawberryUnion
+        | None
+    ):
         raise NotImplementedError
 
     @abstractmethod
-    def get_directive_by_name(self, graphql_name: str) -> Optional[StrawberryDirective]:
+    def get_directive_by_name(self, graphql_name: str) -> StrawberryDirective | None:
         raise NotImplementedError
 
     @abstractmethod
@@ -108,7 +107,7 @@ class BaseSchema(Protocol):
     def _process_errors(
         self,
         errors: list[GraphQLError],
-        execution_context: Optional[ExecutionContext] = None,
+        execution_context: ExecutionContext | None = None,
     ) -> None:
         if self.config.disable_field_suggestions:
             for error in errors:
@@ -119,7 +118,7 @@ class BaseSchema(Protocol):
     def process_errors(
         self,
         errors: list[GraphQLError],
-        execution_context: Optional[ExecutionContext] = None,
+        execution_context: ExecutionContext | None = None,
     ) -> None:
         for error in errors:
             StrawberryLogger.error(error, execution_context)

strawberry/schema/compat.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 from strawberry.scalars import is_scalar as is_strawberry_scalar
 from strawberry.types.base import StrawberryType, has_object_definition
@@ -11,40 +11,40 @@ from strawberry.types.base import StrawberryType, has_object_definition
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
-    from typing_extensions import TypeGuard
+    from typing import TypeGuard
 
     from strawberry.types.scalar import ScalarDefinition, ScalarWrapper
 
 
-def is_input_type(type_: Union[StrawberryType, type]) -> TypeGuard[type]:
+def is_input_type(type_: StrawberryType | type) -> TypeGuard[type]:
     if not has_object_definition(type_):
         return False
     return type_.__strawberry_definition__.is_input
 
 
-def is_interface_type(type_: Union[StrawberryType, type]) -> TypeGuard[type]:
+def is_interface_type(type_: StrawberryType | type) -> TypeGuard[type]:
     if not has_object_definition(type_):
         return False
     return type_.__strawberry_definition__.is_interface
 
 
 def is_scalar(
-    type_: Union[StrawberryType, type],
-    scalar_registry: Mapping[object, Union[ScalarWrapper, ScalarDefinition]],
+    type_: StrawberryType | type,
+    scalar_registry: Mapping[object, ScalarWrapper | ScalarDefinition],
 ) -> TypeGuard[type]:
     return is_strawberry_scalar(type_, scalar_registry)
 
 
-def is_enum(type_: Union[StrawberryType, type]) -> TypeGuard[type]:
+def is_enum(type_: StrawberryType | type) -> TypeGuard[type]:
     return hasattr(type_, "_enum_definition")
 
 
-def is_schema_directive(type_: Union[StrawberryType, type]) -> TypeGuard[type]:
+def is_schema_directive(type_: StrawberryType | type) -> TypeGuard[type]:
     return hasattr(type_, "__strawberry_directive__")
 
 
 # TODO: do we still need this?
-def is_graphql_generic(type_: Union[StrawberryType, type]) -> bool:
+def is_graphql_generic(type_: StrawberryType | type) -> bool:
     if has_object_definition(type_):
         return type_.__strawberry_definition__.is_graphql_generic
 

strawberry/schema/config.py

@@ -1,12 +1,19 @@
 from __future__ import annotations
 
 from dataclasses import InitVar, dataclass, field
-from typing import Any, Callable
+from typing import TYPE_CHECKING, Any, TypedDict
 
 from strawberry.types.info import Info
 
 from .name_converter import NameConverter
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+class BatchingConfig(TypedDict):
+    max_operations: int
+
 
 @dataclass
 class StrawberryConfig:
@@ -17,7 +24,9 @@ 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
+    batching_config: BatchingConfig | None = None
 
     def __post_init__(
         self,

strawberry/schema/exceptions.py

@@ -1,12 +1,10 @@
-from typing import Optional
-
 from strawberry.types.graphql import OperationType
 
 
 class CannotGetOperationTypeError(Exception):
     """Internal error raised when we cannot get the operation type from a GraphQL document."""
 
-    def __init__(self, operation_name: Optional[str]) -> None:
+    def __init__(self, operation_name: str | None) -> None:
         self.operation_name = operation_name
 
     def as_http_error_reason(self) -> str:

strawberry/schema/name_converter.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional, Union, cast
+from typing import TYPE_CHECKING, cast
 from typing_extensions import Protocol
 
 from strawberry.directive import StrawberryDirective
@@ -26,7 +26,7 @@ if TYPE_CHECKING:
 
 class HasGraphQLName(Protocol):
     python_name: str
-    graphql_name: Optional[str]
+    graphql_name: str | None
 
 
 class NameConverter:
@@ -41,7 +41,7 @@ class NameConverter:
 
     def from_type(
         self,
-        type_: Union[StrawberryType, StrawberryDirective],
+        type_: StrawberryType | StrawberryDirective,
     ) -> str:
         if isinstance(type_, (StrawberryDirective, StrawberrySchemaDirective)):
             return self.from_directive(type_)
@@ -85,7 +85,7 @@ class NameConverter:
         return enum_value.name
 
     def from_directive(
-        self, directive: Union[StrawberryDirective, StrawberrySchemaDirective]
+        self, directive: StrawberryDirective | StrawberrySchemaDirective
     ) -> str:
         name = self.get_graphql_name(directive)
 
@@ -134,7 +134,7 @@ class NameConverter:
     def from_generic(
         self,
         generic_type: StrawberryObjectDefinition,
-        types: list[Union[StrawberryType, type]],
+        types: list[StrawberryType | type],
     ) -> str:
         generic_type_name = generic_type.name
 
@@ -146,12 +146,13 @@ class NameConverter:
 
         return "".join(names) + generic_type_name
 
-    def get_name_from_type(self, type_: Union[StrawberryType, type]) -> str:
+    def get_name_from_type(self, type_: StrawberryType | type) -> str:
         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_)