strawberry-graphql 0.243.0__py3-none-any.whl → 0.244.0__py3-none-any.whl

strawberry/aiohttp/views.py

@@ -4,6 +4,7 @@ import asyncio
 import warnings
 from datetime import timedelta
 from io import BytesIO
+from json.decoder import JSONDecodeError
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -16,15 +17,16 @@ from typing import (
     Union,
     cast,
 )
+from typing_extensions import TypeGuard
 
-from aiohttp import web
+from aiohttp import http, web
 from aiohttp.multipart import BodyPartReader
-from strawberry.aiohttp.handlers import (
-    GraphQLTransportWSHandler,
-    GraphQLWSHandler,
+from strawberry.http.async_base_view import (
+    AsyncBaseHTTPView,
+    AsyncHTTPRequestAdapter,
+    AsyncWebSocketAdapter,
 )
-from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncHTTPRequestAdapter
-from strawberry.http.exceptions import HTTPException
+from strawberry.http.exceptions import HTTPException, NonJsonMessageReceived
 from strawberry.http.types import FormData, HTTPMethod, QueryParams
 from strawberry.http.typevars import (
     Context,
@@ -79,11 +81,36 @@ class AioHTTPRequestAdapter(AsyncHTTPRequestAdapter):
         return self.headers.get("content-type")
 
 
+class AioHTTPWebSocketAdapter(AsyncWebSocketAdapter):
+    def __init__(self, request: web.Request, ws: web.WebSocketResponse) -> None:
+        self.request = request
+        self.ws = ws
+
+    async def iter_json(self) -> AsyncGenerator[Dict[str, object], None]:
+        async for ws_message in self.ws:
+            if ws_message.type == http.WSMsgType.TEXT:
+                try:
+                    yield ws_message.json()
+                except JSONDecodeError:
+                    raise NonJsonMessageReceived()
+
+            elif ws_message.type == http.WSMsgType.BINARY:
+                raise NonJsonMessageReceived()
+
+    async def send_json(self, message: Mapping[str, object]) -> None:
+        await self.ws.send_json(message)
+
+    async def close(self, code: int, reason: str) -> None:
+        await self.ws.close(code=code, message=reason.encode())
+
+
 class GraphQLView(
     AsyncBaseHTTPView[
         web.Request,
         Union[web.Response, web.StreamResponse],
         web.Response,
+        web.Request,
+        web.WebSocketResponse,
         Context,
         RootValue,
     ]
@@ -92,10 +119,9 @@ class GraphQLView(
     # bare handler function.
     _is_coroutine = asyncio.coroutines._is_coroutine  # type: ignore[attr-defined]
 
-    graphql_transport_ws_handler_class = GraphQLTransportWSHandler
-    graphql_ws_handler_class = GraphQLWSHandler
     allow_queries_via_get = True
     request_adapter_class = AioHTTPRequestAdapter
+    websocket_adapter_class = AioHTTPWebSocketAdapter
 
     def __init__(
         self,
@@ -138,48 +164,36 @@ class GraphQLView(
     async def get_sub_response(self, request: web.Request) -> web.Response:
         return web.Response()
 
-    async def __call__(self, request: web.Request) -> web.StreamResponse:
+    def is_websocket_request(self, request: web.Request) -> TypeGuard[web.Request]:
         ws = web.WebSocketResponse(protocols=self.subscription_protocols)
-        ws_test = ws.can_prepare(request)
-
-        if not ws_test.ok:
-            try:
-                return await self.run(request=request)
-            except HTTPException as e:
-                return web.Response(
-                    body=e.reason,
-                    status=e.status_code,
-                )
-
-        if ws_test.protocol == GRAPHQL_TRANSPORT_WS_PROTOCOL:
-            return await self.graphql_transport_ws_handler_class(
-                schema=self.schema,
-                debug=self.debug,
-                connection_init_wait_timeout=self.connection_init_wait_timeout,
-                get_context=self.get_context,  # type: ignore
-                get_root_value=self.get_root_value,
-                request=request,
-            ).handle()
-        elif ws_test.protocol == GRAPHQL_WS_PROTOCOL:
-            return await self.graphql_ws_handler_class(
-                schema=self.schema,
-                debug=self.debug,
-                keep_alive=self.keep_alive,
-                keep_alive_interval=self.keep_alive_interval,
-                get_context=self.get_context,
-                get_root_value=self.get_root_value,
-                request=request,
-            ).handle()
-        else:
-            await ws.prepare(request)
-            await ws.close(code=4406, message=b"Subprotocol not acceptable")
-            return ws
+        return ws.can_prepare(request).ok
+
+    async def pick_websocket_subprotocol(self, request: web.Request) -> Optional[str]:
+        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]
+    ) -> web.WebSocketResponse:
+        protocols = [subprotocol] if subprotocol else []
+        ws = web.WebSocketResponse(protocols=protocols)
+        await ws.prepare(request)
+        return ws
+
+    async def __call__(self, request: web.Request) -> web.StreamResponse:
+        try:
+            return await self.run(request=request)
+        except HTTPException as e:
+            return web.Response(
+                body=e.reason,
+                status=e.status_code,
+            )
 
     async def get_root_value(self, request: web.Request) -> Optional[RootValue]:
         return None
 
     async def get_context(
-        self, request: web.Request, response: web.Response
+        self, request: web.Request, response: Union[web.Response, web.WebSocketResponse]
     ) -> Context:
         return {"request": request, "response": response}  # type: ignore
 

strawberry/asgi/__init__.py

@@ -2,9 +2,11 @@ from __future__ import annotations
 
 import warnings
 from datetime import timedelta
+from json import JSONDecodeError
 from typing import (
     TYPE_CHECKING,
     Any,
+    AsyncGenerator,
     AsyncIterator,
     Callable,
     Dict,
@@ -14,6 +16,7 @@ from typing import (
     Union,
     cast,
 )
+from typing_extensions import TypeGuard
 
 from starlette import status
 from starlette.requests import Request
@@ -23,14 +26,14 @@ from starlette.responses import (
     Response,
     StreamingResponse,
 )
-from starlette.websockets import WebSocket
+from starlette.websockets import WebSocket, WebSocketDisconnect, WebSocketState
 
-from strawberry.asgi.handlers import (
-    GraphQLTransportWSHandler,
-    GraphQLWSHandler,
+from strawberry.http.async_base_view import (
+    AsyncBaseHTTPView,
+    AsyncHTTPRequestAdapter,
+    AsyncWebSocketAdapter,
 )
-from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncHTTPRequestAdapter
-from strawberry.http.exceptions import HTTPException
+from strawberry.http.exceptions import HTTPException, NonJsonMessageReceived
 from strawberry.http.types import FormData, HTTPMethod, QueryParams
 from strawberry.http.typevars import (
     Context,
@@ -78,19 +81,41 @@ class ASGIRequestAdapter(AsyncHTTPRequestAdapter):
         )
 
 
+class ASGIWebSocketAdapter(AsyncWebSocketAdapter):
+    def __init__(self, request: WebSocket, response: WebSocket) -> None:
+        self.ws = response
+
+    async def iter_json(self) -> AsyncGenerator[Dict[str, object], None]:
+        try:
+            try:
+                while self.ws.application_state != WebSocketState.DISCONNECTED:
+                    yield await self.ws.receive_json()
+            except (KeyError, JSONDecodeError):
+                raise NonJsonMessageReceived()
+        except WebSocketDisconnect:  # pragma: no cover
+            pass
+
+    async def send_json(self, message: Mapping[str, object]) -> None:
+        await self.ws.send_json(message)
+
+    async def close(self, code: int, reason: str) -> None:
+        await self.ws.close(code=code, reason=reason)
+
+
 class GraphQL(
     AsyncBaseHTTPView[
-        Union[Request, WebSocket],
+        Request,
         Response,
         Response,
+        WebSocket,
+        WebSocket,
         Context,
         RootValue,
     ]
 ):
-    graphql_transport_ws_handler_class = GraphQLTransportWSHandler
-    graphql_ws_handler_class = GraphQLWSHandler
     allow_queries_via_get = True
-    request_adapter_class = ASGIRequestAdapter  # pyright: ignore
+    request_adapter_class = ASGIRequestAdapter
+    websocket_adapter_class = ASGIWebSocketAdapter
 
     def __init__(
         self,
@@ -129,51 +154,25 @@ class GraphQL(
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
         if scope["type"] == "http":
-            return await self.handle_http(scope, receive, send)
+            http_request = Request(scope=scope, receive=receive)
 
-        elif scope["type"] == "websocket":
-            ws = WebSocket(scope, receive=receive, send=send)
-            preferred_protocol = self.pick_preferred_protocol(ws)
-
-            if preferred_protocol == GRAPHQL_TRANSPORT_WS_PROTOCOL:
-                await self.graphql_transport_ws_handler_class(
-                    schema=self.schema,
-                    debug=self.debug,
-                    connection_init_wait_timeout=self.connection_init_wait_timeout,
-                    get_context=self.get_context,
-                    get_root_value=self.get_root_value,
-                    ws=ws,
-                ).handle()
-
-            elif preferred_protocol == GRAPHQL_WS_PROTOCOL:
-                await self.graphql_ws_handler_class(
-                    schema=self.schema,
-                    debug=self.debug,
-                    keep_alive=self.keep_alive,
-                    keep_alive_interval=self.keep_alive_interval,
-                    get_context=self.get_context,
-                    get_root_value=self.get_root_value,
-                    ws=ws,
-                ).handle()
-
-            else:
-                # Subprotocol not acceptable
-                await ws.close(code=4406)
+            try:
+                response = await self.run(http_request)
+            except HTTPException as e:
+                response = PlainTextResponse(e.reason, status_code=e.status_code)
 
+            await response(scope, receive, send)
+        elif scope["type"] == "websocket":
+            ws_request = WebSocket(scope, receive=receive, send=send)
+            await self.run(ws_request)
         else:  # pragma: no cover
             raise ValueError("Unknown scope type: {!r}".format(scope["type"]))
 
-    def pick_preferred_protocol(self, ws: WebSocket) -> Optional[str]:
-        protocols = ws["subprotocols"]
-        intersection = set(protocols) & set(self.protocols)
-        sorted_intersection = sorted(intersection, key=protocols.index)
-        return next(iter(sorted_intersection), None)
-
     async def get_root_value(self, request: Union[Request, WebSocket]) -> Optional[Any]:
         return None
 
     async def get_context(
-        self, request: Union[Request, WebSocket], response: Response
+        self, request: Union[Request, WebSocket], response: Union[Response, WebSocket]
     ) -> Context:
         return {"request": request, "response": response}  # type: ignore
 
@@ -187,21 +186,6 @@ class GraphQL(
 
         return sub_response
 
-    async def handle_http(
-        self,
-        scope: Scope,
-        receive: Receive,
-        send: Send,
-    ) -> None:
-        request = Request(scope=scope, receive=receive)
-
-        try:
-            response = await self.run(request)
-        except HTTPException as e:
-            response = PlainTextResponse(e.reason, status_code=e.status_code)  # pyright: ignore
-
-        await response(scope, receive, send)
-
     async def render_graphql_ide(self, request: Union[Request, WebSocket]) -> Response:
         return HTMLResponse(self.graphql_ide_html)
 
@@ -239,3 +223,20 @@ class GraphQL(
                 **headers,
             },
         )
+
+    def is_websocket_request(
+        self, request: Union[Request, WebSocket]
+    ) -> TypeGuard[WebSocket]:
+        return request.scope["type"] == "websocket"
+
+    async def pick_websocket_subprotocol(self, request: WebSocket) -> Optional[str]:
+        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]
+    ) -> WebSocket:
+        await request.accept(subprotocol=subprotocol)
+        return request

strawberry/channels/__init__.py

@@ -1,6 +1,4 @@
-from .handlers.base import ChannelsConsumer, ChannelsWSConsumer
-from .handlers.graphql_transport_ws_handler import GraphQLTransportWSHandler
-from .handlers.graphql_ws_handler import GraphQLWSHandler
+from .handlers.base import ChannelsConsumer
 from .handlers.http_handler import (
     ChannelsRequest,
     GraphQLHTTPConsumer,
@@ -12,10 +10,7 @@ from .router import GraphQLProtocolTypeRouter
 __all__ = [
     "ChannelsConsumer",
     "ChannelsRequest",
-    "ChannelsWSConsumer",
     "GraphQLProtocolTypeRouter",
-    "GraphQLWSHandler",
-    "GraphQLTransportWSHandler",
     "GraphQLHTTPConsumer",
     "GraphQLWSConsumer",
     "SyncGraphQLHTTPConsumer",

strawberry/channels/handlers/base.py

@@ -16,7 +16,7 @@ from typing_extensions import Literal, Protocol, TypedDict
 from weakref import WeakSet
 
 from channels.consumer import AsyncConsumer
-from channels.generic.websocket import AsyncJsonWebsocketConsumer
+from channels.generic.websocket import AsyncWebsocketConsumer
 
 
 class ChannelsMessage(TypedDict, total=False):
@@ -210,7 +210,7 @@ class ChannelsConsumer(AsyncConsumer):
                 return
 
 
-class ChannelsWSConsumer(ChannelsConsumer, AsyncJsonWebsocketConsumer):
+class ChannelsWSConsumer(ChannelsConsumer, AsyncWebsocketConsumer):
     """Base channels websocket async consumer."""
 
 

strawberry/channels/handlers/http_handler.py

@@ -15,7 +15,7 @@ from typing import (
     Optional,
     Union,
 )
-from typing_extensions import assert_never
+from typing_extensions import TypeGuard, assert_never
 from urllib.parse import parse_qs
 
 from django.conf import settings
@@ -233,6 +233,8 @@ class GraphQLHTTPConsumer(
         ChannelsRequest,
         Union[ChannelsResponse, MultipartChannelsResponse],
         TemporalResponse,
+        ChannelsRequest,
+        TemporalResponse,
         Context,
         RootValue,
     ],
@@ -298,6 +300,21 @@ class GraphQLHTTPConsumer(
             content=self.graphql_ide_html.encode(), content_type="text/html"
         )
 
+    def is_websocket_request(
+        self, request: ChannelsRequest
+    ) -> TypeGuard[ChannelsRequest]:
+        return False
+
+    async def pick_websocket_subprotocol(
+        self, request: ChannelsRequest
+    ) -> Optional[str]:
+        return None
+
+    async def create_websocket_response(
+        self, request: ChannelsRequest, subprotocol: Optional[str]
+    ) -> TemporalResponse:
+        raise NotImplementedError
+
 
 class SyncGraphQLHTTPConsumer(
     BaseGraphQLHTTPConsumer,

strawberry/channels/handlers/ws_handler.py

@@ -1,20 +1,76 @@
 from __future__ import annotations
 
+import asyncio
 import datetime
-from typing import TYPE_CHECKING, Any, Optional, Sequence, Tuple, Union
-
+import json
+from typing import (
+    TYPE_CHECKING,
+    AsyncGenerator,
+    Dict,
+    Mapping,
+    Optional,
+    Tuple,
+    TypedDict,
+    Union,
+)
+from typing_extensions import TypeGuard
+
+from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncWebSocketAdapter
+from strawberry.http.exceptions import NonJsonMessageReceived
+from strawberry.http.typevars import Context, RootValue
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
 
-from .base import ChannelsConsumer, ChannelsWSConsumer
-from .graphql_transport_ws_handler import GraphQLTransportWSHandler
-from .graphql_ws_handler import GraphQLWSHandler
+from .base import ChannelsWSConsumer
 
 if TYPE_CHECKING:
-    from strawberry.http.typevars import Context, RootValue
+    from strawberry.http import GraphQLHTTPResponse
     from strawberry.schema import BaseSchema
 
 
-class GraphQLWSConsumer(ChannelsWSConsumer):
+class ChannelsWebSocketAdapter(AsyncWebSocketAdapter):
+    def __init__(self, request: GraphQLWSConsumer, response: GraphQLWSConsumer) -> None:
+        self.ws_consumer = response
+
+    async def iter_json(self) -> AsyncGenerator[Dict[str, object], None]:
+        while True:
+            message = await self.ws_consumer.message_queue.get()
+
+            if message["disconnected"]:
+                break
+
+            if message["message"] is None:
+                raise NonJsonMessageReceived()
+
+            try:
+                yield json.loads(message["message"])
+            except json.JSONDecodeError:
+                raise NonJsonMessageReceived()
+
+    async def send_json(self, message: Mapping[str, object]) -> None:
+        serialized_message = json.dumps(message)
+        await self.ws_consumer.send(serialized_message)
+
+    async def close(self, code: int, reason: str) -> None:
+        await self.ws_consumer.close(code=code, reason=reason)
+
+
+class MessageQueueData(TypedDict):
+    message: Union[str, None]
+    disconnected: bool
+
+
+class GraphQLWSConsumer(
+    ChannelsWSConsumer,
+    AsyncBaseHTTPView[
+        "GraphQLWSConsumer",
+        "GraphQLWSConsumer",
+        "GraphQLWSConsumer",
+        "GraphQLWSConsumer",
+        "GraphQLWSConsumer",
+        Context,
+        RootValue,
+    ],
+):
     """A channels websocket consumer for GraphQL.
 
     This handles the connections, then hands off to the appropriate
@@ -39,9 +95,7 @@ class GraphQLWSConsumer(ChannelsWSConsumer):
     ```
     """
 
-    graphql_transport_ws_handler_class = GraphQLTransportWSHandler
-    graphql_ws_handler_class = GraphQLWSHandler
-    _handler: Union[GraphQLWSHandler, GraphQLTransportWSHandler]
+    websocket_adapter_class = ChannelsWebSocketAdapter
 
     def __init__(
         self,
@@ -63,70 +117,71 @@ class GraphQLWSConsumer(ChannelsWSConsumer):
         self.keep_alive_interval = keep_alive_interval
         self.debug = debug
         self.protocols = subscription_protocols
+        self.message_queue: asyncio.Queue[MessageQueueData] = asyncio.Queue()
+        self.run_task: Optional[asyncio.Task] = None
 
         super().__init__()
 
-    def pick_preferred_protocol(
-        self, accepted_subprotocols: Sequence[str]
-    ) -> Optional[str]:
-        intersection = set(accepted_subprotocols) & set(self.protocols)
-        sorted_intersection = sorted(intersection, key=accepted_subprotocols.index)
-        return next(iter(sorted_intersection), None)
-
     async def connect(self) -> None:
-        preferred_protocol = self.pick_preferred_protocol(self.scope["subprotocols"])
-
-        if preferred_protocol == GRAPHQL_TRANSPORT_WS_PROTOCOL:
-            self._handler = self.graphql_transport_ws_handler_class(
-                schema=self.schema,
-                debug=self.debug,
-                connection_init_wait_timeout=self.connection_init_wait_timeout,
-                get_context=self.get_context,
-                get_root_value=self.get_root_value,
-                ws=self,
-            )
-        elif preferred_protocol == GRAPHQL_WS_PROTOCOL:
-            self._handler = self.graphql_ws_handler_class(
-                schema=self.schema,
-                debug=self.debug,
-                keep_alive=self.keep_alive,
-                keep_alive_interval=self.keep_alive_interval,
-                get_context=self.get_context,
-                get_root_value=self.get_root_value,
-                ws=self,
-            )
-        else:
-            # Subprotocol not acceptable
-            return await self.close(code=4406)
+        self.run_task = asyncio.create_task(self.run(self))
 
-        await self._handler.handle()
-        return None
-
-    async def receive(self, *args: str, **kwargs: Any) -> None:
-        # Overriding this so that we can pass the errors to handle_invalid_message
-        try:
-            await super().receive(*args, **kwargs)
-        except ValueError:
-            reason = "WebSocket message type must be text"
-            await self._handler.handle_invalid_message(reason)
-
-    async def receive_json(self, content: Any, **kwargs: Any) -> None:
-        await self._handler.handle_message(content)
+    async def receive(
+        self, text_data: Optional[str] = None, bytes_data: Optional[bytes] = None
+    ) -> None:
+        if text_data:
+            self.message_queue.put_nowait({"message": text_data, "disconnected": False})
+        else:
+            self.message_queue.put_nowait({"message": None, "disconnected": False})
 
     async def disconnect(self, code: int) -> None:
-        await self._handler.handle_disconnect(code)
+        self.message_queue.put_nowait({"message": None, "disconnected": True})
+        assert self.run_task
+        await self.run_task
 
-    async def get_root_value(self, request: ChannelsConsumer) -> Optional[RootValue]:
+    async def get_root_value(self, request: GraphQLWSConsumer) -> Optional[RootValue]:
         return None
 
     async def get_context(
-        self, request: ChannelsConsumer, connection_params: Any
+        self, request: GraphQLWSConsumer, response: GraphQLWSConsumer
     ) -> Context:
         return {
             "request": request,
-            "connection_params": connection_params,
             "ws": request,
         }  # type: ignore
 
+    @property
+    def allow_queries_via_get(self) -> bool:
+        return False
+
+    async def get_sub_response(self, request: GraphQLWSConsumer) -> GraphQLWSConsumer:
+        raise NotImplementedError
+
+    def create_response(
+        self, response_data: GraphQLHTTPResponse, sub_response: GraphQLWSConsumer
+    ) -> GraphQLWSConsumer:
+        raise NotImplementedError
+
+    async def render_graphql_ide(self, request: GraphQLWSConsumer) -> GraphQLWSConsumer:
+        raise NotImplementedError
+
+    def is_websocket_request(
+        self, request: GraphQLWSConsumer
+    ) -> TypeGuard[GraphQLWSConsumer]:
+        return True
+
+    async def pick_websocket_subprotocol(
+        self, request: GraphQLWSConsumer
+    ) -> Optional[str]:
+        protocols = request.scope["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: GraphQLWSConsumer, subprotocol: Optional[str]
+    ) -> GraphQLWSConsumer:
+        await request.accept(subprotocol=subprotocol)
+        return request
+
 
 __all__ = ["GraphQLWSConsumer"]

strawberry/django/views.py

@@ -13,6 +13,7 @@ from typing import (
     Union,
     cast,
 )
+from typing_extensions import TypeGuard
 
 from asgiref.sync import markcoroutinefunction
 from django.core.serializers.json import DjangoJSONEncoder
@@ -258,7 +259,13 @@ class GraphQLView(
 class AsyncGraphQLView(
     BaseView,
     AsyncBaseHTTPView[
-        HttpRequest, HttpResponseBase, TemporalHttpResponse, Context, RootValue
+        HttpRequest,
+        HttpResponseBase,
+        TemporalHttpResponse,
+        HttpRequest,
+        TemporalHttpResponse,
+        Context,
+        RootValue,
     ],
     View,
 ):
@@ -312,5 +319,16 @@ class AsyncGraphQLView(
 
         return response
 
+    def is_websocket_request(self, request: HttpRequest) -> TypeGuard[HttpRequest]:
+        return False
+
+    async def pick_websocket_subprotocol(self, request: HttpRequest) -> Optional[str]:
+        raise NotImplementedError
+
+    async def create_websocket_response(
+        self, request: HttpRequest, subprotocol: Optional[str]
+    ) -> TemporalHttpResponse:
+        raise NotImplementedError
+
 
 __all__ = ["GraphQLView", "AsyncGraphQLView"]

strawberry/ext/mypy_plugin.py

@@ -481,7 +481,14 @@ def strawberry_pydantic_class_callback(ctx: ClassDefContext) -> None:
                         # Based on pydantic's default value
                         # https://github.com/pydantic/pydantic/pull/9606/files#diff-469037bbe55bbf9aa359480a16040d368c676adad736e133fb07e5e20d6ac523R1066
                         extra["force_typevars_invariant"] = False
-
+                    if PYDANTIC_VERSION >= (2, 9, 0):
+                        extra["model_strict"] = model_type.type.metadata[
+                            PYDANTIC_METADATA_KEY
+                        ]["config"].get("strict", False)
+                        extra["is_root_model_root"] = any(
+                            "pydantic.root_model.RootModel" in base.fullname
+                            for base in model_type.type.mro[:-1]
+                        )
                 add_method(
                     ctx,
                     "to_pydantic",