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

strawberry/aiohttp/handlers/graphql_ws_handler.py

@@ -1,69 +0,0 @@
-from __future__ import annotations
-
-from contextlib import suppress
-from typing import TYPE_CHECKING, Any, Callable, Optional
-
-from aiohttp import http, web
-from strawberry.subscriptions import GRAPHQL_WS_PROTOCOL
-from strawberry.subscriptions.protocols.graphql_ws.handlers import BaseGraphQLWSHandler
-
-if TYPE_CHECKING:
-    from strawberry.schema import BaseSchema
-    from strawberry.subscriptions.protocols.graphql_ws.types import OperationMessage
-
-
-class GraphQLWSHandler(BaseGraphQLWSHandler):
-    def __init__(
-        self,
-        schema: BaseSchema,
-        debug: bool,
-        keep_alive: bool,
-        keep_alive_interval: float,
-        get_context: Callable,
-        get_root_value: Callable,
-        request: web.Request,
-    ) -> None:
-        super().__init__(schema, debug, keep_alive, keep_alive_interval)
-        self._get_context = get_context
-        self._get_root_value = get_root_value
-        self._request = request
-        self._ws = web.WebSocketResponse(protocols=[GRAPHQL_WS_PROTOCOL])
-
-    async def get_context(self) -> Any:
-        return await self._get_context(request=self._request, response=self._ws)
-
-    async def get_root_value(self) -> Any:
-        return await self._get_root_value(request=self._request)
-
-    async def send_json(self, data: OperationMessage) -> None:
-        await self._ws.send_json(data)
-
-    async def close(self, code: int = 1000, reason: Optional[str] = None) -> None:
-        message = reason.encode() if reason else b""
-        await self._ws.close(code=code, message=message)
-
-    async def handle_request(self) -> Any:
-        await self._ws.prepare(self._request)
-
-        try:
-            async for ws_message in self._ws:  # type: http.WSMessage
-                if ws_message.type == http.WSMsgType.TEXT:
-                    message: OperationMessage = ws_message.json()
-                    await self.handle_message(message)
-                else:
-                    await self.close(
-                        code=1002, reason="WebSocket message type must be text"
-                    )
-        finally:
-            if self.keep_alive_task:
-                self.keep_alive_task.cancel()
-                with suppress(BaseException):
-                    await self.keep_alive_task
-
-            for operation_id in list(self.subscriptions.keys()):
-                await self.cleanup_operation(operation_id)
-
-        return self._ws
-
-
-__all__ = ["GraphQLWSHandler"]

strawberry/asgi/handlers/__init__.py

@@ -1,6 +0,0 @@
-from strawberry.asgi.handlers.graphql_transport_ws_handler import (
-    GraphQLTransportWSHandler,
-)
-from strawberry.asgi.handlers.graphql_ws_handler import GraphQLWSHandler
-
-__all__ = ["GraphQLTransportWSHandler", "GraphQLWSHandler"]

strawberry/asgi/handlers/graphql_transport_ws_handler.py

@@ -1,66 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Callable
-
-from starlette.websockets import WebSocketDisconnect, WebSocketState
-
-from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL
-from strawberry.subscriptions.protocols.graphql_transport_ws.handlers import (
-    BaseGraphQLTransportWSHandler,
-)
-
-if TYPE_CHECKING:
-    from datetime import timedelta
-
-    from starlette.websockets import WebSocket
-
-    from strawberry.schema import BaseSchema
-
-
-class GraphQLTransportWSHandler(BaseGraphQLTransportWSHandler):
-    def __init__(
-        self,
-        schema: BaseSchema,
-        debug: bool,
-        connection_init_wait_timeout: timedelta,
-        get_context: Callable,
-        get_root_value: Callable,
-        ws: WebSocket,
-    ) -> None:
-        super().__init__(schema, debug, connection_init_wait_timeout)
-        self._get_context = get_context
-        self._get_root_value = get_root_value
-        self._ws = ws
-
-    async def get_context(self) -> Any:
-        return await self._get_context(request=self._ws, response=None)
-
-    async def get_root_value(self) -> Any:
-        return await self._get_root_value(request=self._ws)
-
-    async def send_json(self, data: dict) -> None:
-        await self._ws.send_json(data)
-
-    async def close(self, code: int, reason: str) -> None:
-        await self._ws.close(code=code, reason=reason)
-
-    async def handle_request(self) -> None:
-        await self._ws.accept(subprotocol=GRAPHQL_TRANSPORT_WS_PROTOCOL)
-        self.on_request_accepted()
-
-        try:
-            while self._ws.application_state != WebSocketState.DISCONNECTED:
-                try:
-                    message = await self._ws.receive_json()
-                except KeyError:  # noqa: PERF203
-                    error_message = "WebSocket message type must be text"
-                    await self.handle_invalid_message(error_message)
-                else:
-                    await self.handle_message(message)
-        except WebSocketDisconnect:  # pragma: no cover
-            pass
-        finally:
-            await self.shutdown()
-
-
-__all__ = ["GraphQLTransportWSHandler"]

strawberry/asgi/handlers/graphql_ws_handler.py

@@ -1,71 +0,0 @@
-from __future__ import annotations
-
-from contextlib import suppress
-from typing import TYPE_CHECKING, Any, Callable, Optional
-
-from starlette.websockets import WebSocketDisconnect, WebSocketState
-
-from strawberry.subscriptions import GRAPHQL_WS_PROTOCOL
-from strawberry.subscriptions.protocols.graphql_ws.handlers import BaseGraphQLWSHandler
-
-if TYPE_CHECKING:
-    from starlette.websockets import WebSocket
-
-    from strawberry.schema import BaseSchema
-    from strawberry.subscriptions.protocols.graphql_ws.types import OperationMessage
-
-
-class GraphQLWSHandler(BaseGraphQLWSHandler):
-    def __init__(
-        self,
-        schema: BaseSchema,
-        debug: bool,
-        keep_alive: bool,
-        keep_alive_interval: float,
-        get_context: Callable,
-        get_root_value: Callable,
-        ws: WebSocket,
-    ) -> None:
-        super().__init__(schema, debug, keep_alive, keep_alive_interval)
-        self._get_context = get_context
-        self._get_root_value = get_root_value
-        self._ws = ws
-
-    async def get_context(self) -> Any:
-        return await self._get_context(request=self._ws, response=None)
-
-    async def get_root_value(self) -> Any:
-        return await self._get_root_value(request=self._ws)
-
-    async def send_json(self, data: OperationMessage) -> None:
-        await self._ws.send_json(data)
-
-    async def close(self, code: int = 1000, reason: Optional[str] = None) -> None:
-        await self._ws.close(code=code, reason=reason)
-
-    async def handle_request(self) -> Any:
-        await self._ws.accept(subprotocol=GRAPHQL_WS_PROTOCOL)
-
-        try:
-            while self._ws.application_state != WebSocketState.DISCONNECTED:
-                try:
-                    message = await self._ws.receive_json()
-                except KeyError:  # noqa: PERF203
-                    await self.close(
-                        code=1002, reason="WebSocket message type must be text"
-                    )
-                else:
-                    await self.handle_message(message)
-        except WebSocketDisconnect:  # pragma: no cover
-            pass
-        finally:
-            if self.keep_alive_task:
-                self.keep_alive_task.cancel()
-                with suppress(BaseException):
-                    await self.keep_alive_task
-
-            for operation_id in list(self.subscriptions.keys()):
-                await self.cleanup_operation(operation_id)
-
-
-__all__ = ["GraphQLWSHandler"]

strawberry/channels/handlers/graphql_transport_ws_handler.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Callable, Optional
-
-from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL
-from strawberry.subscriptions.protocols.graphql_transport_ws.handlers import (
-    BaseGraphQLTransportWSHandler,
-)
-
-if TYPE_CHECKING:
-    from datetime import timedelta
-
-    from strawberry.channels.handlers.base import ChannelsWSConsumer
-    from strawberry.schema import BaseSchema
-
-
-class GraphQLTransportWSHandler(BaseGraphQLTransportWSHandler):
-    def __init__(
-        self,
-        schema: BaseSchema,
-        debug: bool,
-        connection_init_wait_timeout: timedelta,
-        get_context: Callable,
-        get_root_value: Callable,
-        ws: ChannelsWSConsumer,
-    ) -> None:
-        super().__init__(schema, debug, connection_init_wait_timeout)
-        self._get_context = get_context
-        self._get_root_value = get_root_value
-        self._ws = ws
-
-    async def get_context(self) -> Any:
-        return await self._get_context(
-            request=self._ws, connection_params=self.connection_params
-        )
-
-    async def get_root_value(self) -> Any:
-        return await self._get_root_value(request=self._ws)
-
-    async def send_json(self, data: dict) -> None:
-        await self._ws.send_json(data)
-
-    async def close(self, code: int = 1000, reason: Optional[str] = None) -> None:
-        # TODO: We are using `self._ws.base_send` directly instead of `self._ws.close`
-        # because the later doesn't accept the `reason` argument.
-        await self._ws.base_send(
-            {
-                "type": "websocket.close",
-                "code": code,
-                "reason": reason or "",
-            }
-        )
-
-    async def handle_request(self) -> Any:
-        await self._ws.accept(subprotocol=GRAPHQL_TRANSPORT_WS_PROTOCOL)
-        self.on_request_accepted()
-
-    async def handle_disconnect(self, code: int) -> None:
-        await self.shutdown()
-
-
-__all__ = ["GraphQLTransportWSHandler"]

strawberry/channels/handlers/graphql_ws_handler.py

@@ -1,72 +0,0 @@
-from __future__ import annotations
-
-from contextlib import suppress
-from typing import TYPE_CHECKING, Any, Callable, Optional
-
-from strawberry.subscriptions import GRAPHQL_WS_PROTOCOL
-from strawberry.subscriptions.protocols.graphql_ws.handlers import BaseGraphQLWSHandler
-
-if TYPE_CHECKING:
-    from strawberry.channels.handlers.base import ChannelsWSConsumer
-    from strawberry.schema import BaseSchema
-    from strawberry.subscriptions.protocols.graphql_ws.types import OperationMessage
-
-
-class GraphQLWSHandler(BaseGraphQLWSHandler):
-    def __init__(
-        self,
-        schema: BaseSchema,
-        debug: bool,
-        keep_alive: bool,
-        keep_alive_interval: float,
-        get_context: Callable,
-        get_root_value: Callable,
-        ws: ChannelsWSConsumer,
-    ) -> None:
-        super().__init__(schema, debug, keep_alive, keep_alive_interval)
-        self._get_context = get_context
-        self._get_root_value = get_root_value
-        self._ws = ws
-
-    async def get_context(self) -> Any:
-        return await self._get_context(
-            request=self._ws, connection_params=self.connection_params
-        )
-
-    async def get_root_value(self) -> Any:
-        return await self._get_root_value(request=self._ws)
-
-    async def send_json(self, data: OperationMessage) -> None:
-        await self._ws.send_json(data)
-
-    async def close(self, code: int = 1000, reason: Optional[str] = None) -> None:
-        # TODO: We are using `self._ws.base_send` directly instead of `self._ws.close`
-        # because the latler doesn't accept the `reason` argument.
-        await self._ws.base_send(
-            {
-                "type": "websocket.close",
-                "code": code,
-                "reason": reason or "",
-            }
-        )
-
-    async def handle_request(self) -> Any:
-        await self._ws.accept(subprotocol=GRAPHQL_WS_PROTOCOL)
-
-    async def handle_disconnect(self, code: int) -> None:
-        if self.keep_alive_task:
-            self.keep_alive_task.cancel()
-            with suppress(BaseException):
-                await self.keep_alive_task
-
-        for operation_id in list(self.subscriptions.keys()):
-            await self.cleanup_operation(operation_id)
-
-    async def handle_invalid_message(self, error_message: str) -> None:
-        # This is not part of the BaseGraphQLWSHandler's interface, but the
-        # channels integration is a high level wrapper that forwards this to
-        # both us and the BaseGraphQLTransportWSHandler.
-        await self.close(code=1002, reason=error_message)
-
-
-__all__ = ["GraphQLWSHandler"]

strawberry/fastapi/handlers/__init__.py

@@ -1,6 +0,0 @@
-from strawberry.fastapi.handlers.graphql_transport_ws_handler import (
-    GraphQLTransportWSHandler,
-)
-from strawberry.fastapi.handlers.graphql_ws_handler import GraphQLWSHandler
-
-__all__ = ["GraphQLTransportWSHandler", "GraphQLWSHandler"]

strawberry/fastapi/handlers/graphql_transport_ws_handler.py

@@ -1,20 +0,0 @@
-from typing import Any
-
-from strawberry.asgi.handlers import (
-    GraphQLTransportWSHandler as BaseGraphQLTransportWSHandler,
-)
-from strawberry.fastapi.context import BaseContext
-
-
-class GraphQLTransportWSHandler(BaseGraphQLTransportWSHandler):
-    async def get_context(self) -> Any:
-        context = await self._get_context()
-        if isinstance(context, BaseContext):
-            context.connection_params = self.connection_params
-        return context
-
-    async def get_root_value(self) -> Any:
-        return await self._get_root_value()
-
-
-__all__ = ["GraphQLTransportWSHandler"]

strawberry/fastapi/handlers/graphql_ws_handler.py

@@ -1,18 +0,0 @@
-from typing import Any
-
-from strawberry.asgi.handlers import GraphQLWSHandler as BaseGraphQLWSHandler
-from strawberry.fastapi.context import BaseContext
-
-
-class GraphQLWSHandler(BaseGraphQLWSHandler):
-    async def get_context(self) -> Any:
-        context = await self._get_context()
-        if isinstance(context, BaseContext):
-            context.connection_params = self.connection_params
-        return context
-
-    async def get_root_value(self) -> Any:
-        return await self._get_root_value()
-
-
-__all__ = ["GraphQLWSHandler"]

strawberry/litestar/handlers/graphql_transport_ws_handler.py

@@ -1,60 +0,0 @@
-from collections.abc import Callable
-from datetime import timedelta
-from typing import Any
-
-from litestar import WebSocket
-from litestar.exceptions import SerializationException, WebSocketDisconnect
-from strawberry.schema import BaseSchema
-from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL
-from strawberry.subscriptions.protocols.graphql_transport_ws.handlers import (
-    BaseGraphQLTransportWSHandler,
-)
-
-
-class GraphQLTransportWSHandler(BaseGraphQLTransportWSHandler):
-    def __init__(
-        self,
-        schema: BaseSchema,
-        debug: bool,
-        connection_init_wait_timeout: timedelta,
-        get_context: Callable,
-        get_root_value: Callable,
-        ws: WebSocket,
-    ) -> None:
-        super().__init__(schema, debug, connection_init_wait_timeout)
-        self._get_context = get_context
-        self._get_root_value = get_root_value
-        self._ws = ws
-
-    async def get_context(self) -> Any:
-        return await self._get_context()
-
-    async def get_root_value(self) -> Any:
-        return await self._get_root_value()
-
-    async def send_json(self, data: dict) -> None:
-        await self._ws.send_json(data)
-
-    async def close(self, code: int, reason: str) -> None:
-        await self._ws.close(code=code, reason=reason)
-
-    async def handle_request(self) -> None:
-        await self._ws.accept(subprotocols=GRAPHQL_TRANSPORT_WS_PROTOCOL)
-        self.on_request_accepted()
-
-        try:
-            while self._ws.connection_state != "disconnect":
-                try:
-                    message = await self._ws.receive_json()
-                except (SerializationException, ValueError):  # noqa: PERF203
-                    error_message = "WebSocket message type must be text"
-                    await self.handle_invalid_message(error_message)
-                else:
-                    await self.handle_message(message)
-        except WebSocketDisconnect:  # pragma: no cover
-            pass
-        finally:
-            await self.shutdown()
-
-
-__all__ = ["GraphQLTransportWSHandler"]

strawberry/litestar/handlers/graphql_ws_handler.py

@@ -1,66 +0,0 @@
-from collections.abc import Callable
-from contextlib import suppress
-from typing import Any, Optional
-
-from litestar import WebSocket
-from litestar.exceptions import SerializationException, WebSocketDisconnect
-from strawberry.schema import BaseSchema
-from strawberry.subscriptions import GRAPHQL_WS_PROTOCOL
-from strawberry.subscriptions.protocols.graphql_ws.handlers import BaseGraphQLWSHandler
-from strawberry.subscriptions.protocols.graphql_ws.types import OperationMessage
-
-
-class GraphQLWSHandler(BaseGraphQLWSHandler):
-    def __init__(
-        self,
-        schema: BaseSchema,
-        debug: bool,
-        keep_alive: bool,
-        keep_alive_interval: float,
-        get_context: Callable,
-        get_root_value: Callable,
-        ws: WebSocket,
-    ) -> None:
-        super().__init__(schema, debug, keep_alive, keep_alive_interval)
-        self._get_context = get_context
-        self._get_root_value = get_root_value
-        self._ws = ws
-
-    async def get_context(self) -> Any:
-        return await self._get_context()
-
-    async def get_root_value(self) -> Any:
-        return await self._get_root_value()
-
-    async def send_json(self, data: OperationMessage) -> None:
-        await self._ws.send_json(data)
-
-    async def close(self, code: int = 1000, reason: Optional[str] = None) -> None:
-        await self._ws.close(code=code, reason=reason)
-
-    async def handle_request(self) -> Any:
-        await self._ws.accept(subprotocols=GRAPHQL_WS_PROTOCOL)
-
-        try:
-            while self._ws.connection_state != "disconnect":
-                try:
-                    message = await self._ws.receive_json()
-                except (SerializationException, ValueError):  # noqa: PERF203
-                    await self.close(
-                        code=1002, reason="WebSocket message type must be text"
-                    )
-                else:
-                    await self.handle_message(message)
-        except WebSocketDisconnect:  # pragma: no cover
-            pass
-        finally:
-            if self.keep_alive_task:
-                self.keep_alive_task.cancel()
-                with suppress(BaseException):
-                    await self.keep_alive_task
-
-            for operation_id in list(self.subscriptions.keys()):
-                await self.cleanup_operation(operation_id)
-
-
-__all__ = ["GraphQLWSHandler"]