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

strawberry/federation/schema.py

@@ -44,18 +44,17 @@ FederationAny = scalar(NewType("_Any", object), name="_Any")  # type: ignore
 class Schema(BaseSchema):
     def __init__(
         self,
-        query: Optional[type] = None,
-        mutation: Optional[type] = None,
-        subscription: Optional[type] = None,
+        query: type | None = None,
+        mutation: type | None = None,
+        subscription: type | None = None,
         # TODO: we should update directives' type in the main schema
         directives: Iterable[type] = (),
         types: Iterable[type] = (),
         extensions: Iterable[Union[type["SchemaExtension"], "SchemaExtension"]] = (),
-        execution_context_class: Optional[type["GraphQLExecutionContext"]] = None,
+        execution_context_class: type["GraphQLExecutionContext"] | None = None,
         config: Optional["StrawberryConfig"] = None,
-        scalar_overrides: Optional[
-            dict[object, Union[type, "ScalarWrapper", "ScalarDefinition"]]
-        ] = None,
+        scalar_overrides: dict[object, Union[type, "ScalarWrapper", "ScalarDefinition"]]
+        | None = None,
         schema_directives: Iterable[object] = (),
         enable_federation_2: bool = False,
     ) -> None:
@@ -85,9 +84,9 @@ class Schema(BaseSchema):
 
     def _get_federation_query_type(
         self,
-        query: Optional[type[WithStrawberryObjectDefinition]],
-        mutation: Optional[type[WithStrawberryObjectDefinition]],
-        subscription: Optional[type[WithStrawberryObjectDefinition]],
+        query: type[WithStrawberryObjectDefinition] | None,
+        mutation: type[WithStrawberryObjectDefinition] | None,
+        subscription: type[WithStrawberryObjectDefinition] | None,
         additional_types: Iterable[type[WithStrawberryObjectDefinition]],
     ) -> type:
         """Returns a new query type that includes the _service field.
@@ -124,7 +123,7 @@ class Schema(BaseSchema):
 
         if entity_type:
             self.entities_resolver.__annotations__["return"] = list[
-                Optional[entity_type]  # type: ignore
+                entity_type | None  # type: ignore
             ]
 
             entities_field = strawberry.field(
@@ -250,7 +249,7 @@ class Schema(BaseSchema):
         directive_by_url[import_url].add(f"@{name}")
 
     def _add_link_directives(
-        self, additional_directives: Optional[list[object]] = None
+        self, additional_directives: list[object] | None = None
     ) -> None:
         from .schema_directives import FederationDirective, Link
 
@@ -312,11 +311,11 @@ class Schema(BaseSchema):
 
 
 def _get_entity_type(
-    query: Optional[type[WithStrawberryObjectDefinition]],
-    mutation: Optional[type[WithStrawberryObjectDefinition]],
-    subscription: Optional[type[WithStrawberryObjectDefinition]],
+    query: type[WithStrawberryObjectDefinition] | None,
+    mutation: type[WithStrawberryObjectDefinition] | None,
+    subscription: type[WithStrawberryObjectDefinition] | None,
     additional_types: Iterable[type[WithStrawberryObjectDefinition]],
-) -> Optional[StrawberryUnion]:
+) -> StrawberryUnion | None:
     # recursively iterate over the schema to find all types annotated with @key
     # if no types are annotated with @key, then the _Entity union and Query._entities
     # field should not be added to the schema

strawberry/federation/schema_directive.py

@@ -1,5 +1,6 @@
 import dataclasses
-from typing import Callable, Optional, TypeVar
+from collections.abc import Callable
+from typing import TypeVar
 from typing_extensions import dataclass_transform
 
 from strawberry.directive import directive_field
@@ -11,12 +12,12 @@ from strawberry.types.type_resolver import _get_fields
 
 @dataclasses.dataclass
 class ComposeOptions:
-    import_url: Optional[str]
+    import_url: str | None
 
 
 @dataclasses.dataclass
 class StrawberryFederationSchemaDirective(StrawberrySchemaDirective):
-    compose_options: Optional[ComposeOptions] = None
+    compose_options: ComposeOptions | None = None
 
 
 T = TypeVar("T", bound=type)
@@ -30,12 +31,12 @@ T = TypeVar("T", bound=type)
 def schema_directive(
     *,
     locations: list[Location],
-    description: Optional[str] = None,
-    name: Optional[str] = None,
+    description: str | None = None,
+    name: str | None = None,
     repeatable: bool = False,
     print_definition: bool = True,
     compose: bool = False,
-    import_url: Optional[str] = None,
+    import_url: str | None = None,
 ) -> Callable[[T], T]:
     def _wrap(cls: T) -> T:
         cls = _wrap_dataclass(cls)  # type: ignore

strawberry/federation/schema_directives.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import ClassVar, Optional
+from typing import ClassVar
 
 from strawberry import directive_field
 from strawberry.schema_directive import Location, schema_directive
@@ -59,7 +59,7 @@ class Provides(FederationDirective):
 )
 class Key(FederationDirective):
     fields: FieldSet
-    resolvable: Optional[bool] = True
+    resolvable: bool | None = True
     imported_from: ClassVar[ImportedFrom] = ImportedFrom(
         name="key", url="https://specs.apollo.dev/federation/v2.7"
     )
@@ -81,17 +81,17 @@ class Shareable(FederationDirective):
     locations=[Location.SCHEMA], name="link", repeatable=True, print_definition=False
 )
 class Link:
-    url: Optional[str]
-    as_: Optional[str] = directive_field(name="as")
-    for_: Optional[LinkPurpose] = directive_field(name="for")
-    import_: Optional[list[Optional[LinkImport]]] = directive_field(name="import")
+    url: str | None
+    as_: str | None = directive_field(name="as")
+    for_: LinkPurpose | None = directive_field(name="for")
+    import_: list[LinkImport | None] | None = directive_field(name="import")
 
     def __init__(
         self,
-        url: Optional[str] = UNSET,
-        as_: Optional[str] = UNSET,
-        for_: Optional[LinkPurpose] = UNSET,
-        import_: Optional[list[Optional[LinkImport]]] = UNSET,
+        url: str | None = UNSET,
+        as_: str | None = UNSET,
+        for_: LinkPurpose | None = UNSET,
+        import_: list[LinkImport | None] | None = UNSET,
     ) -> None:
         self.url = url
         self.as_ = as_
@@ -128,7 +128,7 @@ class Tag(FederationDirective):
 )
 class Override(FederationDirective):
     override_from: str = directive_field(name="from")
-    label: Optional[str] = UNSET
+    label: str | None = UNSET
     imported_from: ClassVar[ImportedFrom] = ImportedFrom(
         name="override", url="https://specs.apollo.dev/federation/v2.7"
     )

strawberry/federation/union.py

@@ -1,5 +1,5 @@
 from collections.abc import Collection, Iterable
-from typing import Any, Optional
+from typing import Any
 
 from strawberry.types.union import StrawberryUnion
 from strawberry.types.union import union as base_union
@@ -7,12 +7,12 @@ from strawberry.types.union import union as base_union
 
 def union(
     name: str,
-    types: Optional[Collection[type[Any]]] = None,
+    types: Collection[type[Any]] | None = None,
     *,
-    description: Optional[str] = None,
+    description: str | None = None,
     directives: Iterable[object] = (),
     inaccessible: bool = False,
-    tags: Optional[Iterable[str]] = (),
+    tags: Iterable[str] | None = (),
 ) -> StrawberryUnion:
     """Creates a new named Union type.
 

strawberry/flask/views.py

@@ -3,75 +3,34 @@ from __future__ import annotations
 import warnings
 from typing import (
     TYPE_CHECKING,
-    Any,
     ClassVar,
-    Optional,
-    Union,
-    cast,
+    TypeGuard,
 )
-from typing_extensions import TypeGuard
+
+from lia import AsyncFlaskHTTPRequestAdapter, FlaskHTTPRequestAdapter, HTTPException
 
 from flask import Request, Response, render_template_string, request
 from flask.views import View
-from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncHTTPRequestAdapter
-from strawberry.http.exceptions import HTTPException
-from strawberry.http.sync_base_view import (
-    SyncBaseHTTPView,
-    SyncHTTPRequestAdapter,
-)
-from strawberry.http.types import FormData, HTTPMethod, QueryParams
+from strawberry.http.async_base_view import AsyncBaseHTTPView
+from strawberry.http.sync_base_view import SyncBaseHTTPView
 from strawberry.http.typevars import Context, RootValue
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping
-
     from flask.typing import ResponseReturnValue
+
     from strawberry.http import GraphQLHTTPResponse
     from strawberry.http.ides import GraphQL_IDE
     from strawberry.schema.base import BaseSchema
 
 
-class FlaskHTTPRequestAdapter(SyncHTTPRequestAdapter):
-    def __init__(self, request: Request) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        return self.request.args.to_dict()
-
-    @property
-    def body(self) -> Union[str, bytes]:
-        return self.request.data.decode()
-
-    @property
-    def method(self) -> HTTPMethod:
-        return cast("HTTPMethod", self.request.method.upper())
-
-    @property
-    def headers(self) -> Mapping[str, str]:
-        return self.request.headers  # type: ignore
-
-    @property
-    def post_data(self) -> Mapping[str, Union[str, bytes]]:
-        return self.request.form
-
-    @property
-    def files(self) -> Mapping[str, Any]:
-        return self.request.files
-
-    @property
-    def content_type(self) -> Optional[str]:
-        return self.request.content_type
-
-
 class BaseGraphQLView:
-    graphql_ide: Optional[GraphQL_IDE]
+    graphql_ide: GraphQL_IDE | None
 
     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,
         multipart_uploads_enabled: bool = False,
     ) -> None:
@@ -91,7 +50,9 @@ class BaseGraphQLView:
             self.graphql_ide = graphql_ide
 
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: Response
+        self,
+        response_data: GraphQLHTTPResponse | list[GraphQLHTTPResponse],
+        sub_response: Response,
     ) -> Response:
         sub_response.set_data(self.encode_json(response_data))  # type: ignore
 
@@ -110,7 +71,7 @@ class GraphQLView(
     def get_context(self, request: Request, response: Response) -> Context:
         return {"request": request, "response": response}  # type: ignore
 
-    def get_root_value(self, request: Request) -> Optional[RootValue]:
+    def get_root_value(self, request: Request) -> RootValue | None:
         return None
 
     def get_sub_response(self, request: Request) -> Response:
@@ -129,36 +90,6 @@ class GraphQLView(
         return render_template_string(self.graphql_ide_html)  # type: ignore
 
 
-class AsyncFlaskHTTPRequestAdapter(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 self.request.data.decode()
-
-    async def get_form_data(self) -> FormData:
-        return FormData(
-            files=self.request.files,
-            form=self.request.form,
-        )
-
-
 class AsyncGraphQLView(
     BaseGraphQLView,
     AsyncBaseHTTPView[
@@ -173,7 +104,7 @@ class AsyncGraphQLView(
     async def get_context(self, request: Request, response: Response) -> Context:
         return {"request": request, "response": response}  # type: ignore
 
-    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_sub_response(self, request: Request) -> Response:
@@ -195,11 +126,11 @@ class AsyncGraphQLView(
     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
     ) -> Response:
         raise NotImplementedError
 

strawberry/http/__init__.py

@@ -1,26 +1,36 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Optional
-from typing_extensions import Literal, TypedDict
+from typing import Any, Literal
+from typing_extensions import TypedDict
 
-if TYPE_CHECKING:
-    from strawberry.types import ExecutionResult
+from strawberry.schema._graphql_core import (
+    GraphQLIncrementalExecutionResults,
+    ResultType,
+)
 
 
 class GraphQLHTTPResponse(TypedDict, total=False):
-    data: Optional[dict[str, object]]
-    errors: Optional[list[object]]
-    extensions: Optional[dict[str, object]]
-
-
-def process_result(result: ExecutionResult) -> GraphQLHTTPResponse:
-    data: GraphQLHTTPResponse = {"data": result.data}
-
-    if result.errors:
-        data["errors"] = [err.formatted for err in result.errors]
-    if result.extensions:
-        data["extensions"] = result.extensions
+    data: dict[str, object] | None
+    errors: list[object] | None
+    extensions: dict[str, object] | None
+    hasNext: bool | None
+    completed: list[Any] | None
+    pending: list[Any] | None
+    initial: list[Any] | None
+    incremental: list[Any] | None
+
+
+def process_result(result: ResultType) -> GraphQLHTTPResponse:
+    if isinstance(result, GraphQLIncrementalExecutionResults):
+        return result
+
+    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
 
@@ -29,10 +39,10 @@ def process_result(result: ExecutionResult) -> GraphQLHTTPResponse:
 class GraphQLRequestData:
     # query is optional here as it can be added by an extensions
     # (for example an extension for persisted queries)
-    query: Optional[str]
-    variables: Optional[dict[str, Any]]
-    operation_name: Optional[str]
-    extensions: Optional[dict[str, Any]]
+    query: str | None
+    variables: dict[str, Any] | None
+    operation_name: str | None
+    extensions: dict[str, Any] | None
     protocol: Literal["http", "multipart-subscription"] = "http"