strawberry-graphql 0.269.0.dev1747164009__tar.gz → 0.270.0__tar.gz

{strawberry_graphql-0.269.0.dev1747164009 → strawberry_graphql-0.270.0}/PKG-INFO

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

{strawberry_graphql-0.269.0.dev1747164009 → strawberry_graphql-0.270.0}/pyproject.toml

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

strawberry_graphql-0.270.0/strawberry/quart/views.py

@@ -0,0 +1,216 @@
+import asyncio
+import warnings
+from collections.abc import AsyncGenerator, Mapping, Sequence
+from datetime import timedelta
+from json.decoder import JSONDecodeError
+from typing import TYPE_CHECKING, Callable, ClassVar, Optional, Union, cast
+from typing_extensions import TypeGuard
+
+from quart import Request, Response, Websocket, request, websocket
+from quart.ctx import has_websocket_context
+from quart.views import View
+from strawberry.http.async_base_view import (
+    AsyncBaseHTTPView,
+    AsyncHTTPRequestAdapter,
+    AsyncWebSocketAdapter,
+)
+from strawberry.http.exceptions import (
+    HTTPException,
+    NonJsonMessageReceived,
+    NonTextMessageReceived,
+    WebSocketDisconnected,
+)
+from strawberry.http.ides import GraphQL_IDE
+from strawberry.http.types import FormData, HTTPMethod, QueryParams
+from strawberry.http.typevars import Context, RootValue
+from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
+
+if TYPE_CHECKING:
+    from quart.typing import ResponseReturnValue
+    from strawberry.http import GraphQLHTTPResponse
+    from strawberry.schema.base import BaseSchema
+
+
+class QuartHTTPRequestAdapter(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 (await self.request.data).decode()
+
+    async def get_form_data(self) -> FormData:
+        files = await self.request.files
+        form = await self.request.form
+        return FormData(files=files, form=form)
+
+
+class QuartWebSocketAdapter(AsyncWebSocketAdapter):
+    def __init__(
+        self, view: AsyncBaseHTTPView, request: Websocket, response: Response
+    ) -> None:
+        super().__init__(view)
+        self.ws = request
+
+    async def iter_json(
+        self, *, ignore_parsing_errors: bool = False
+    ) -> AsyncGenerator[object, None]:
+        try:
+            while True:
+                # Raises asyncio.CancelledError when the connection is closed.
+                # https://quart.palletsprojects.com/en/latest/how_to_guides/websockets.html#detecting-disconnection
+                message = await self.ws.receive()
+
+                if not isinstance(message, str):
+                    raise NonTextMessageReceived
+
+                try:
+                    yield self.view.decode_json(message)
+                except JSONDecodeError as e:
+                    if not ignore_parsing_errors:
+                        raise NonJsonMessageReceived from e
+        except asyncio.CancelledError:
+            pass
+
+    async def send_json(self, message: Mapping[str, object]) -> None:
+        try:
+            # Raises asyncio.CancelledError when the connection is closed.
+            # https://quart.palletsprojects.com/en/latest/how_to_guides/websockets.html#detecting-disconnection
+            await self.ws.send(self.view.encode_json(message))
+        except asyncio.CancelledError as exc:
+            raise WebSocketDisconnected from exc
+
+    async def close(self, code: int, reason: str) -> None:
+        await self.ws.close(code, reason=reason)
+
+
+class GraphQLView(
+    AsyncBaseHTTPView[
+        Request, Response, Response, Websocket, Response, Context, RootValue
+    ],
+    View,
+):
+    methods: ClassVar[list[str]] = ["GET", "POST"]
+    allow_queries_via_get: bool = True
+    request_adapter_class = QuartHTTPRequestAdapter
+    websocket_adapter_class = QuartWebSocketAdapter
+
+    def __init__(
+        self,
+        schema: "BaseSchema",
+        graphiql: Optional[bool] = None,
+        graphql_ide: Optional[GraphQL_IDE] = "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,
+        ),
+        connection_init_wait_timeout: timedelta = timedelta(minutes=1),
+        multipart_uploads_enabled: bool = False,
+    ) -> None:
+        self.schema = schema
+        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
+
+        if graphiql is not None:
+            warnings.warn(
+                "The `graphiql` argument is deprecated in favor of `graphql_ide`",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            self.graphql_ide = "graphiql" if graphiql else None
+        else:
+            self.graphql_ide = graphql_ide
+
+    async def render_graphql_ide(self, request: Request) -> Response:
+        return Response(self.graphql_ide_html)
+
+    def create_response(
+        self, response_data: "GraphQLHTTPResponse", sub_response: Response
+    ) -> Response:
+        sub_response.set_data(self.encode_json(response_data))
+
+        return sub_response
+
+    async def get_context(
+        self, request: Union[Request, Websocket], response: Response
+    ) -> Context:
+        return {"request": request, "response": response}  # type: ignore
+
+    async def get_root_value(
+        self, request: Union[Request, Websocket]
+    ) -> Optional[RootValue]:
+        return None
+
+    async def get_sub_response(self, request: Request) -> Response:
+        return Response(status=200, content_type="application/json")
+
+    async def dispatch_request(self, **kwargs: object) -> "ResponseReturnValue":
+        try:
+            return await self.run(
+                request=websocket if has_websocket_context() else request
+            )
+        except HTTPException as e:
+            return Response(
+                response=e.reason,
+                status=e.status_code,
+            )
+
+    async def create_streaming_response(
+        self,
+        request: Request,
+        stream: Callable[[], AsyncGenerator[str, None]],
+        sub_response: Response,
+        headers: dict[str, str],
+    ) -> Response:
+        return (
+            stream(),
+            sub_response.status_code,
+            {  # type: ignore
+                **sub_response.headers,
+                **headers,
+            },
+        )
+
+    def is_websocket_request(
+        self, request: Union[Request, Websocket]
+    ) -> TypeGuard[Websocket]:
+        return has_websocket_context()
+
+    async def pick_websocket_subprotocol(self, request: Websocket) -> Optional[str]:
+        protocols = request.requested_subprotocols
+        intersection = set(protocols) & set(self.subscription_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]
+    ) -> Response:
+        await request.accept(subprotocol=subprotocol)
+        return Response()
+
+
+__all__ = ["GraphQLView"]

{strawberry_graphql-0.269.0.dev1747164009 → strawberry_graphql-0.270.0}/strawberry/schema/schema_converter.py

@@ -270,10 +270,7 @@ class GraphQLCoreConverter:
                 GlobalID,
                 name=global_id_name,
                 description=GraphQLID.description,
-                parse_literal=lambda v, vars=None: GlobalID.from_id(  # noqa: A006
-                    GraphQLID.parse_literal(v, vars)
-                ),
-                parse_value=GlobalID.from_id,
+                parse_value=lambda v: v,
                 serialize=str,
                 specified_by_url=("https://relay.dev/graphql/objectidentification.htm"),
             )
@@ -803,6 +800,13 @@ class GraphQLCoreConverter:
         return _resolver
 
     def from_scalar(self, scalar: type) -> GraphQLScalarType:
+        from strawberry.relay.types import GlobalID
+
+        if not self.config.relay_use_legacy_global_id and scalar is GlobalID:
+            from strawberry import ID
+
+            return self.from_scalar(ID)
+
         scalar_definition: ScalarDefinition
 
         if scalar in self.scalar_registry:
@@ -817,21 +821,13 @@ class GraphQLCoreConverter:
 
         scalar_name = self.config.name_converter.from_type(scalar_definition)
 
-        from strawberry.relay import GlobalID
-
         if scalar_name not in self.type_map:
-            if scalar is GlobalID and hasattr(GraphQLNamedType, "reserved_types"):
-                GraphQLNamedType.reserved_types.pop("ID")
-
             implementation = (
                 scalar_definition.implementation
                 if scalar_definition.implementation is not None
                 else _make_scalar_type(scalar_definition)
             )
 
-            if scalar is GlobalID and hasattr(GraphQLNamedType, "reserved_types"):
-                GraphQLNamedType.reserved_types["ID"] = implementation
-
             self.type_map[scalar_name] = ConcreteType(
                 definition=scalar_definition, implementation=implementation
             )
@@ -841,17 +837,7 @@ class GraphQLCoreConverter:
             # TODO: the other definition might not be a scalar, we should
             # handle this case better, since right now we assume it is a scalar
 
-            # special case to allow GlobalID to be used as an ID scalar
-            # TODO: we need to find a better way to handle this, might be
-            # worth reworking our scalar implementation.
-            if (
-                hasattr(other_definition, "origin")
-                and hasattr(scalar_definition, "origin")
-                and other_definition.origin == GlobalID
-                and scalar_definition.origin == GraphQLID
-            ):
-                pass
-            elif other_definition != scalar_definition:
+            if other_definition != scalar_definition:
                 other_definition = cast("ScalarDefinition", other_definition)
 
                 raise ScalarAlreadyRegisteredError(scalar_definition, other_definition)

{strawberry_graphql-0.269.0.dev1747164009 → strawberry_graphql-0.270.0}/strawberry/types/arguments.py

@@ -170,6 +170,11 @@ def convert_argument(
         ]
 
     if is_scalar(type_, scalar_registry):
+        from strawberry.relay.types import GlobalID
+
+        if type_ is GlobalID:
+            return GlobalID.from_id(value)  # type: ignore
+
         return value
 
     if isinstance(type_, EnumDefinition):

strawberry_graphql-0.269.0.dev1747164009/strawberry/quart/views.py

@@ -1,137 +0,0 @@
-import warnings
-from collections.abc import AsyncGenerator, Mapping
-from typing import TYPE_CHECKING, Callable, ClassVar, Optional, cast
-from typing_extensions import TypeGuard
-
-from quart import Request, Response, request
-from quart.views import View
-from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncHTTPRequestAdapter
-from strawberry.http.exceptions import HTTPException
-from strawberry.http.ides import GraphQL_IDE
-from strawberry.http.types import FormData, HTTPMethod, QueryParams
-from strawberry.http.typevars import Context, RootValue
-
-if TYPE_CHECKING:
-    from quart.typing import ResponseReturnValue
-    from strawberry.http import GraphQLHTTPResponse
-    from strawberry.schema.base import BaseSchema
-
-
-class QuartHTTPRequestAdapter(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 (await self.request.data).decode()
-
-    async def get_form_data(self) -> FormData:
-        files = await self.request.files
-        form = await self.request.form
-        return FormData(files=files, form=form)
-
-
-class GraphQLView(
-    AsyncBaseHTTPView[
-        Request, Response, Response, Request, Response, Context, RootValue
-    ],
-    View,
-):
-    methods: ClassVar[list[str]] = ["GET", "POST"]
-    allow_queries_via_get: bool = True
-    request_adapter_class = QuartHTTPRequestAdapter
-
-    def __init__(
-        self,
-        schema: "BaseSchema",
-        graphiql: Optional[bool] = None,
-        graphql_ide: Optional[GraphQL_IDE] = "graphiql",
-        allow_queries_via_get: bool = True,
-        multipart_uploads_enabled: bool = False,
-    ) -> None:
-        self.schema = schema
-        self.allow_queries_via_get = allow_queries_via_get
-        self.multipart_uploads_enabled = multipart_uploads_enabled
-
-        if graphiql is not None:
-            warnings.warn(
-                "The `graphiql` argument is deprecated in favor of `graphql_ide`",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            self.graphql_ide = "graphiql" if graphiql else None
-        else:
-            self.graphql_ide = graphql_ide
-
-    async def render_graphql_ide(self, request: Request) -> Response:
-        return Response(self.graphql_ide_html)
-
-    def create_response(
-        self, response_data: "GraphQLHTTPResponse", sub_response: Response
-    ) -> Response:
-        sub_response.set_data(self.encode_json(response_data))
-
-        return sub_response
-
-    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]:
-        return None
-
-    async def get_sub_response(self, request: Request) -> Response:
-        return Response(status=200, content_type="application/json")
-
-    async def dispatch_request(self) -> "ResponseReturnValue":  # type: ignore
-        try:
-            return await self.run(request=request)
-        except HTTPException as e:
-            return Response(
-                response=e.reason,
-                status=e.status_code,
-            )
-
-    async def create_streaming_response(
-        self,
-        request: Request,
-        stream: Callable[[], AsyncGenerator[str, None]],
-        sub_response: Response,
-        headers: dict[str, str],
-    ) -> Response:
-        return (
-            stream(),
-            sub_response.status_code,
-            {  # type: ignore
-                **sub_response.headers,
-                **headers,
-            },
-        )
-
-    def is_websocket_request(self, request: Request) -> TypeGuard[Request]:
-        return False
-
-    async def pick_websocket_subprotocol(self, request: Request) -> Optional[str]:
-        raise NotImplementedError
-
-    async def create_websocket_response(
-        self, request: Request, subprotocol: Optional[str]
-    ) -> Response:
-        raise NotImplementedError
-
-
-__all__ = ["GraphQLView"]