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

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/aiohttp/test/client.py

@@ -1,27 +1,20 @@
 from __future__ import annotations
 
 import warnings
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Optional,
-)
+from typing import Any
 
 from strawberry.test.client import BaseGraphQLTestClient, Response
 
-if TYPE_CHECKING:
-    from collections.abc import Mapping
-
 
 class GraphQLTestClient(BaseGraphQLTestClient):
     async def query(
         self,
         query: str,
-        variables: Optional[dict[str, Mapping]] = None,
-        headers: Optional[dict[str, object]] = None,
-        asserts_errors: Optional[bool] = None,
-        files: Optional[dict[str, object]] = None,
-        assert_no_errors: Optional[bool] = True,
+        variables: dict[str, Any] | None = None,
+        headers: dict[str, object] | None = None,
+        asserts_errors: bool | None = None,
+        files: dict[str, object] | None = None,
+        assert_no_errors: bool | None = True,
     ) -> Response:
         body = self._build_body(query, variables, files)
 
@@ -54,8 +47,8 @@ class GraphQLTestClient(BaseGraphQLTestClient):
     async def request(
         self,
         body: dict[str, object],
-        headers: Optional[dict[str, object]] = None,
-        files: Optional[dict[str, object]] = None,
+        headers: dict[str, object] | None = None,
+        files: dict[str, object] | None = None,
     ) -> Any:
         return await self._client.post(
             self.url,

strawberry/aiohttp/views.py

@@ -3,32 +3,24 @@ from __future__ import annotations
 import asyncio
 import warnings
 from datetime import timedelta
-from io import BytesIO
 from json.decoder import JSONDecodeError
 from typing import (
     TYPE_CHECKING,
-    Any,
-    Callable,
-    Optional,
-    Union,
-    cast,
+    TypeGuard,
 )
-from typing_extensions import TypeGuard
 
 from aiohttp import ClientConnectionResetError, http, web
-from aiohttp.multipart import BodyPartReader
+from lia import AiohttpHTTPRequestAdapter, HTTPException
+
 from strawberry.http.async_base_view import (
     AsyncBaseHTTPView,
-    AsyncHTTPRequestAdapter,
     AsyncWebSocketAdapter,
 )
 from strawberry.http.exceptions import (
-    HTTPException,
     NonJsonMessageReceived,
     NonTextMessageReceived,
     WebSocketDisconnected,
 )
-from strawberry.http.types import FormData, HTTPMethod, QueryParams
 from strawberry.http.typevars import (
     Context,
     RootValue,
@@ -36,54 +28,13 @@ from strawberry.http.typevars import (
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncGenerator, Mapping, Sequence
+    from collections.abc import AsyncGenerator, Callable, Mapping, Sequence
 
     from strawberry.http import GraphQLHTTPResponse
     from strawberry.http.ides import GraphQL_IDE
     from strawberry.schema import BaseSchema
 
 
-class AiohttpHTTPRequestAdapter(AsyncHTTPRequestAdapter):
-    def __init__(self, request: web.Request) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        return self.request.query.copy()  # type: ignore[attr-defined]
-
-    async def get_body(self) -> str:
-        return (await self.request.content.read()).decode()
-
-    @property
-    def method(self) -> HTTPMethod:
-        return cast("HTTPMethod", self.request.method.upper())
-
-    @property
-    def headers(self) -> Mapping[str, str]:
-        return self.request.headers
-
-    async def get_form_data(self) -> FormData:
-        reader = await self.request.multipart()
-
-        data: dict[str, Any] = {}
-        files: dict[str, Any] = {}
-
-        while field := await reader.next():
-            assert isinstance(field, BodyPartReader)
-            assert field.name
-
-            if field.filename:
-                files[field.name] = BytesIO(await field.read(decode=False))
-            else:
-                data[field.name] = await field.text()
-
-        return FormData(files=files, form=data)
-
-    @property
-    def content_type(self) -> Optional[str]:
-        return self.headers.get("content-type")
-
-
 class AiohttpWebSocketAdapter(AsyncWebSocketAdapter):
     def __init__(
         self, view: AsyncBaseHTTPView, request: web.Request, ws: web.WebSocketResponse
@@ -119,7 +70,7 @@ class AiohttpWebSocketAdapter(AsyncWebSocketAdapter):
 class GraphQLView(
     AsyncBaseHTTPView[
         web.Request,
-        Union[web.Response, web.StreamResponse],
+        web.Response | web.StreamResponse,
         web.Response,
         web.Request,
         web.WebSocketResponse,
@@ -133,17 +84,16 @@ class GraphQLView(
 
     allow_queries_via_get = True
     request_adapter_class = AiohttpHTTPRequestAdapter
-    websocket_adapter_class = AiohttpWebSocketAdapter
+    websocket_adapter_class = AiohttpWebSocketAdapter  # type: ignore
 
     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,
         keep_alive: bool = True,
         keep_alive_interval: float = 1,
-        debug: bool = False,
         subscription_protocols: Sequence[str] = (
             GRAPHQL_TRANSPORT_WS_PROTOCOL,
             GRAPHQL_WS_PROTOCOL,
@@ -155,7 +105,6 @@ class GraphQLView(
         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
@@ -180,12 +129,12 @@ class GraphQLView(
         ws = web.WebSocketResponse(protocols=self.subscription_protocols)
         return ws.can_prepare(request).ok
 
-    async def pick_websocket_subprotocol(self, request: web.Request) -> Optional[str]:
+    async def pick_websocket_subprotocol(self, request: web.Request) -> str | None:
         ws = web.WebSocketResponse(protocols=self.subscription_protocols)
         return ws.can_prepare(request).protocol
 
     async def create_websocket_response(
-        self, request: web.Request, subprotocol: Optional[str]
+        self, request: web.Request, subprotocol: str | None
     ) -> web.WebSocketResponse:
         protocols = [subprotocol] if subprotocol else []
         ws = web.WebSocketResponse(protocols=protocols)
@@ -201,16 +150,18 @@ class GraphQLView(
                 status=e.status_code,
             )
 
-    async def get_root_value(self, request: web.Request) -> Optional[RootValue]:
+    async def get_root_value(self, request: web.Request) -> RootValue | None:
         return None
 
     async def get_context(
-        self, request: web.Request, response: Union[web.Response, web.WebSocketResponse]
+        self, request: web.Request, response: web.Response | web.WebSocketResponse
     ) -> Context:
         return {"request": request, "response": response}  # type: ignore
 
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: web.Response
+        self,
+        response_data: GraphQLHTTPResponse | list[GraphQLHTTPResponse],
+        sub_response: web.Response,
     ) -> web.Response:
         sub_response.text = self.encode_json(response_data)
         sub_response.content_type = "application/json"

strawberry/annotation.py

@@ -5,18 +5,21 @@ import typing
 import warnings
 from collections import abc
 from enum import Enum
+from types import UnionType
 from typing import (
     TYPE_CHECKING,
     Annotated,
     Any,
     ForwardRef,
-    Optional,
     TypeVar,
     Union,
     cast,
+    get_args,
+    get_origin,
 )
-from typing_extensions import Self, get_args, get_origin
+from typing_extensions import Self
 
+from strawberry.streamable import StrawberryStreamable
 from strawberry.types.base import (
     StrawberryList,
     StrawberryMaybe,
@@ -57,14 +60,14 @@ class StrawberryAnnotation:
 
     def __init__(
         self,
-        annotation: Union[object, str],
+        annotation: object | str,
         *,
-        namespace: Optional[dict[str, Any]] = None,
+        namespace: dict[str, Any] | None = None,
     ) -> None:
         self.raw_annotation = annotation
         self.namespace = namespace
 
-        self.__resolve_cache__: Optional[Union[StrawberryType, type]] = None
+        self.__resolve_cache__: StrawberryType | type | None = None
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, StrawberryAnnotation):
@@ -77,8 +80,8 @@ class StrawberryAnnotation:
 
     @staticmethod
     def from_annotation(
-        annotation: object, namespace: Optional[dict[str, Any]] = None
-    ) -> Optional[StrawberryAnnotation]:
+        annotation: object, namespace: dict[str, Any] | None = None
+    ) -> StrawberryAnnotation | None:
         if annotation is None:
             return None
 
@@ -87,7 +90,7 @@ class StrawberryAnnotation:
         return annotation
 
     @property
-    def annotation(self) -> Union[object, str]:
+    def annotation(self) -> object | str:
         """Return evaluated type on success or fallback to raw (string) annotation."""
         try:
             return self.evaluate()
@@ -97,7 +100,7 @@ class StrawberryAnnotation:
             return self.raw_annotation
 
     @annotation.setter
-    def annotation(self, value: Union[object, str]) -> None:
+    def annotation(self, value: object | str) -> None:
         self.raw_annotation = value
 
         self.__resolve_cache__ = None
@@ -124,16 +127,44 @@ class StrawberryAnnotation:
 
         return evaled_type, []
 
-    def resolve(self) -> Union[StrawberryType, type]:
+    def resolve(
+        self,
+        *,
+        type_definition: StrawberryObjectDefinition | None = None,
+    ) -> StrawberryType | type:
         """Return resolved (transformed) annotation."""
-        if self.__resolve_cache__ is None:
-            self.__resolve_cache__ = self._resolve()
-
-        return self.__resolve_cache__
-
-    def _resolve(self) -> Union[StrawberryType, type]:
+        if (resolved := self.__resolve_cache__) is None:
+            resolved = self._resolve()
+            self.__resolve_cache__ = resolved
+
+        # If this is a generic field, try to resolve it using its origin's
+        # specialized type_var_map
+        if self._is_type_generic(resolved) and type_definition is not None:
+            from strawberry.types.base import StrawberryType
+
+            specialized_type_var_map = type_definition.specialized_type_var_map
+            if specialized_type_var_map and isinstance(resolved, StrawberryType):
+                resolved = resolved.copy_with(specialized_type_var_map)
+
+            # If the field is still generic, try to resolve it from the type_definition
+            # that is asking for it.
+            if (
+                self._is_type_generic(resolved)
+                and type_definition.type_var_map
+                and isinstance(resolved, StrawberryType)
+            ):
+                resolved = resolved.copy_with(type_definition.type_var_map)
+
+            # Resolve the type again to resolve any `Annotated` types
+            resolved = self._resolve_evaled_type(resolved)
+
+        return resolved
+
+    def _resolve(self) -> StrawberryType | type:
         evaled_type = cast("Any", self.evaluate())
+        return self._resolve_evaled_type(evaled_type)
 
+    def _resolve_evaled_type(self, evaled_type: Any) -> StrawberryType | type:
         if is_private(evaled_type):
             return evaled_type
 
@@ -143,6 +174,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 self._is_maybe(evaled_type):
@@ -213,7 +246,7 @@ class StrawberryAnnotation:
         # passed as we can safely use `Union` for both optional types
         # (e.g. `Optional[str]`) and optional unions (e.g.
         # `Optional[Union[TypeA, TypeB]]`)
-        child_type = Union[non_optional_types]  # type: ignore
+        child_type = Union[non_optional_types]  # type: ignore  # noqa: UP007
 
         of_type = StrawberryAnnotation(
             annotation=child_type,
@@ -289,6 +322,20 @@ class StrawberryAnnotation:
             return False
         return issubclass(annotation, Enum)
 
+    @classmethod
+    def _is_type_generic(cls, type_: StrawberryType | type) -> bool:
+        """Returns True if `resolver_type` is generic else False."""
+        from strawberry.types.base import StrawberryType
+
+        if isinstance(type_, StrawberryType):
+            return type_.is_graphql_generic
+
+        # solves the Generic subclass case
+        if has_object_definition(type_):
+            return type_.__strawberry_definition__.is_graphql_generic
+
+        return False
+
     @classmethod
     def _is_graphql_generic(cls, annotation: Any) -> bool:
         if hasattr(annotation, "__origin__"):
@@ -332,6 +379,10 @@ 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
@@ -364,16 +415,10 @@ class StrawberryAnnotation:
         """Returns True if annotation is a Union."""
         # this check is needed because unions declared with the new syntax `A | B`
         # don't have a `__origin__` property on them, but they are instances of
-        # `UnionType`, which is only available in Python 3.10+
-        if sys.version_info >= (3, 10):
-            from types import UnionType
-
-            if isinstance(annotation, UnionType):
-                return True
+        if isinstance(annotation, UnionType):
+            return True
 
         # unions declared as Union[A, B] fall through to this check
-        # even on python 3.10+
-
         annotation_origin = getattr(annotation, "__origin__", None)
 
         if annotation_origin is typing.Union:

strawberry/asgi/__init__.py

@@ -5,13 +5,10 @@ from datetime import timedelta
 from json import JSONDecodeError
 from typing import (
     TYPE_CHECKING,
-    Callable,
-    Optional,
-    Union,
-    cast,
+    TypeGuard,
 )
-from typing_extensions import TypeGuard
 
+from lia import HTTPException, StarletteRequestAdapter
 from starlette import status
 from starlette.requests import Request
 from starlette.responses import (
@@ -24,16 +21,13 @@ from starlette.websockets import WebSocket, WebSocketDisconnect, WebSocketState
 
 from strawberry.http.async_base_view import (
     AsyncBaseHTTPView,
-    AsyncHTTPRequestAdapter,
     AsyncWebSocketAdapter,
 )
 from strawberry.http.exceptions import (
-    HTTPException,
     NonJsonMessageReceived,
     NonTextMessageReceived,
     WebSocketDisconnected,
 )
-from strawberry.http.types import FormData, HTTPMethod, QueryParams
 from strawberry.http.typevars import (
     Context,
     RootValue,
@@ -41,7 +35,13 @@ from strawberry.http.typevars import (
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncGenerator, AsyncIterator, Mapping, Sequence
+    from collections.abc import (
+        AsyncGenerator,
+        AsyncIterator,
+        Callable,
+        Mapping,
+        Sequence,
+    )
 
     from starlette.types import Receive, Scope, Send
 
@@ -50,38 +50,6 @@ if TYPE_CHECKING:
     from strawberry.schema import BaseSchema
 
 
-class ASGIRequestAdapter(AsyncHTTPRequestAdapter):
-    def __init__(self, request: Request) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        return self.request.query_params
-
-    @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.headers.get("content-type")
-
-    async def get_body(self) -> bytes:
-        return await self.request.body()
-
-    async def get_form_data(self) -> FormData:
-        multipart_data = await self.request.form()
-
-        return FormData(
-            files=multipart_data,
-            form=multipart_data,
-        )
-
-
 class ASGIWebSocketAdapter(AsyncWebSocketAdapter):
     def __init__(
         self, view: AsyncBaseHTTPView, request: WebSocket, response: WebSocket
@@ -127,18 +95,17 @@ class GraphQL(
     ]
 ):
     allow_queries_via_get = True
-    request_adapter_class = ASGIRequestAdapter
-    websocket_adapter_class = ASGIWebSocketAdapter
+    request_adapter_class = StarletteRequestAdapter
+    websocket_adapter_class = ASGIWebSocketAdapter  # type: ignore
 
     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,
         keep_alive: bool = False,
         keep_alive_interval: float = 1,
-        debug: bool = False,
         subscription_protocols: Sequence[str] = (
             GRAPHQL_TRANSPORT_WS_PROTOCOL,
             GRAPHQL_WS_PROTOCOL,
@@ -150,7 +117,6 @@ class GraphQL(
         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.protocols = subscription_protocols
         self.connection_init_wait_timeout = connection_init_wait_timeout
         self.multipart_uploads_enabled = multipart_uploads_enabled
@@ -181,19 +147,17 @@ class GraphQL(
         else:  # pragma: no cover
             raise ValueError("Unknown scope type: {!r}".format(scope["type"]))
 
-    async def get_root_value(
-        self, request: Union[Request, WebSocket]
-    ) -> Optional[RootValue]:
+    async def get_root_value(self, request: Request | WebSocket) -> RootValue | None:
         return None
 
     async def get_context(
-        self, request: Union[Request, WebSocket], response: Union[Response, WebSocket]
+        self, request: Request | WebSocket, response: Response | WebSocket
     ) -> Context:
         return {"request": request, "response": response}  # type: ignore
 
     async def get_sub_response(
         self,
-        request: Union[Request, WebSocket],
+        request: Request | WebSocket,
     ) -> Response:
         sub_response = Response()
         sub_response.status_code = None  # type: ignore
@@ -205,7 +169,9 @@ class GraphQL(
         return HTMLResponse(self.graphql_ide_html)
 
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: Response
+        self,
+        response_data: GraphQLHTTPResponse | list[GraphQLHTTPResponse],
+        sub_response: Response,
     ) -> Response:
         response = Response(
             self.encode_json(response_data),
@@ -240,18 +206,18 @@ class GraphQL(
         )
 
     def is_websocket_request(
-        self, request: Union[Request, WebSocket]
+        self, request: Request | WebSocket
     ) -> TypeGuard[WebSocket]:
         return request.scope["type"] == "websocket"
 
-    async def pick_websocket_subprotocol(self, request: WebSocket) -> Optional[str]:
+    async def pick_websocket_subprotocol(self, request: WebSocket) -> str | None:
         protocols = request["subprotocols"]
         intersection = set(protocols) & set(self.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]
+        self, request: WebSocket, subprotocol: str | None
     ) -> WebSocket:
         await request.accept(subprotocol=subprotocol)
         return request

strawberry/asgi/test/client.py

@@ -1,21 +1,21 @@
 from __future__ import annotations
 
 import json
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from strawberry.test import BaseGraphQLTestClient
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
-    from typing_extensions import Literal
+    from typing import Literal
 
 
 class GraphQLTestClient(BaseGraphQLTestClient):
     def _build_body(
         self,
         query: str,
-        variables: Optional[dict[str, Mapping]] = None,
-        files: Optional[dict[str, object]] = None,
+        variables: dict[str, Mapping] | None = None,
+        files: dict[str, object] | None = None,
     ) -> dict[str, object]:
         body: dict[str, object] = {"query": query}
 
@@ -36,8 +36,8 @@ class GraphQLTestClient(BaseGraphQLTestClient):
     def request(
         self,
         body: dict[str, object],
-        headers: Optional[dict[str, object]] = None,
-        files: Optional[dict[str, object]] = None,
+        headers: dict[str, object] | None = None,
+        files: dict[str, object] | None = None,
     ) -> Any:
         return self._client.post(
             self.url,