strawberry-graphql 0.168.2__tar.gz → 0.170.0__tar.gz

{strawberry_graphql-0.168.2 → strawberry_graphql-0.170.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.168.2
+Version: 0.170.0
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT

{strawberry_graphql-0.168.2 → strawberry_graphql-0.170.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.168.2"
+version = "0.170.0"
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "MIT"
@@ -151,7 +151,7 @@ markers = [
     "fastapi",
     "chalice",
     "flask",
-    "starlite,"
+    "starlite"
 ]
 asyncio_mode = "auto"
 filterwarnings = [

{strawberry_graphql-0.168.2 → strawberry_graphql-0.170.0}/strawberry/aiohttp/handlers/__init__.py

@@ -2,6 +2,5 @@ from strawberry.aiohttp.handlers.graphql_transport_ws_handler import (
     GraphQLTransportWSHandler,
 )
 from strawberry.aiohttp.handlers.graphql_ws_handler import GraphQLWSHandler
-from strawberry.aiohttp.handlers.http_handler import HTTPHandler
 
-__all__ = ["GraphQLTransportWSHandler", "GraphQLWSHandler", "HTTPHandler"]
+__all__ = ["GraphQLTransportWSHandler", "GraphQLWSHandler"]

strawberry_graphql-0.170.0/strawberry/aiohttp/views.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import asyncio
+from datetime import timedelta
+from io import BytesIO
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Iterable,
+    Mapping,
+    Optional,
+    cast,
+)
+
+from aiohttp import web
+from strawberry.aiohttp.handlers import (
+    GraphQLTransportWSHandler,
+    GraphQLWSHandler,
+)
+from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncHTTPRequestAdapter
+from strawberry.http.exceptions import HTTPException
+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
+from strawberry.utils.graphiql import get_graphiql_html
+
+if TYPE_CHECKING:
+    from strawberry.http import GraphQLHTTPResponse
+    from strawberry.schema import BaseSchema
+
+
+class AioHTTPRequestAdapter(AsyncHTTPRequestAdapter):
+    def __init__(self, request: web.Request):
+        self.request = request
+
+    @property
+    def query_params(self) -> QueryParams:
+        return self.request.query.copy()
+
+    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] = {}
+
+        async for field in reader:
+            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.request.content_type
+
+
+class GraphQLView(
+    AsyncBaseHTTPView[web.Request, web.Response, web.Response, Context, RootValue]
+):
+    # Mark the view as coroutine so that AIOHTTP does not confuse it with a deprecated
+    # 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
+
+    def __init__(
+        self,
+        schema: BaseSchema,
+        graphiql: bool = True,
+        allow_queries_via_get: bool = True,
+        keep_alive: bool = True,
+        keep_alive_interval: float = 1,
+        debug: bool = False,
+        subscription_protocols: Iterable[str] = (
+            GRAPHQL_TRANSPORT_WS_PROTOCOL,
+            GRAPHQL_WS_PROTOCOL,
+        ),
+        connection_init_wait_timeout: timedelta = timedelta(minutes=1),
+    ):
+        self.schema = schema
+        self.graphiql = graphiql
+        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
+
+    def render_graphiql(self, request: web.Request) -> web.Response:
+        # TODO: get_graphiql_html should be on self
+        html_string = get_graphiql_html()
+
+        return web.Response(text=html_string, content_type="text/html")
+
+    async def get_sub_response(self, request: web.Request) -> web.Response:
+        return web.Response()
+
+    async def __call__(self, request: web.Request) -> web.StreamResponse:
+        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
+
+    async def get_root_value(self, request: web.Request) -> Optional[RootValue]:
+        return None
+
+    async def get_context(
+        self, request: web.Request, response: web.Response
+    ) -> Context:
+        return {"request": request, "response": response}  # type: ignore
+
+    def create_response(
+        self, response_data: GraphQLHTTPResponse, sub_response: web.Response
+    ) -> web.Response:
+        sub_response.text = self.encode_json(response_data)
+        sub_response.content_type = "application/json"
+
+        return sub_response

strawberry_graphql-0.170.0/strawberry/asgi/__init__.py

@@ -0,0 +1,206 @@
+from __future__ import annotations
+
+from datetime import timedelta
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Mapping,
+    Optional,
+    Sequence,
+    Union,
+    cast,
+)
+
+from starlette import status
+from starlette.requests import Request
+from starlette.responses import HTMLResponse, PlainTextResponse, Response
+from starlette.websockets import WebSocket
+
+from strawberry.asgi.handlers import (
+    GraphQLTransportWSHandler,
+    GraphQLWSHandler,
+)
+from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncHTTPRequestAdapter
+from strawberry.http.exceptions import HTTPException
+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
+from strawberry.utils.graphiql import get_graphiql_html
+
+if TYPE_CHECKING:
+    from starlette.types import Receive, Scope, Send
+
+    from strawberry.http import GraphQLHTTPResponse
+    from strawberry.schema import BaseSchema
+
+
+class ASGIRequestAdapter(AsyncHTTPRequestAdapter):
+    def __init__(self, request: Request) -> None:
+        self.request = request
+
+    @property
+    def query_params(self) -> QueryParams:
+        return dict(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 GraphQL(
+    AsyncBaseHTTPView[
+        Union[Request, WebSocket],
+        Response,
+        Response,
+        Context,
+        RootValue,
+    ]
+):
+    graphql_transport_ws_handler_class = GraphQLTransportWSHandler
+    graphql_ws_handler_class = GraphQLWSHandler
+    allow_queries_via_get = True
+    request_adapter_class = ASGIRequestAdapter  # pyright: ignore
+
+    def __init__(
+        self,
+        schema: BaseSchema,
+        graphiql: bool = True,
+        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,
+        ),
+        connection_init_wait_timeout: timedelta = timedelta(minutes=1),
+    ) -> None:
+        self.schema = schema
+        self.graphiql = graphiql
+        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
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send):
+        if scope["type"] == "http":
+            return await self.handle_http(scope, receive, send)
+
+        elif scope["type"] == "websocket":
+            ws = WebSocket(scope=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)
+
+        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
+    ) -> Context:
+        return {"request": request, "response": response}  # type: ignore
+
+    async def get_sub_response(
+        self,
+        request: Union[Request, WebSocket],
+    ) -> Response:
+        sub_response = Response()
+        sub_response.status_code = None  # type: ignore
+        del sub_response.headers["content-length"]
+
+        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)
+
+    def render_graphiql(self, request: Union[Request, WebSocket]) -> Response:
+        html = get_graphiql_html()
+
+        return HTMLResponse(html)
+
+    def create_response(
+        self, response_data: GraphQLHTTPResponse, sub_response: Response
+    ) -> Response:
+        response = Response(
+            self.encode_json(response_data),
+            status_code=status.HTTP_200_OK,
+            media_type="application/json",
+        )
+
+        response.headers.raw.extend(sub_response.headers.raw)
+
+        if sub_response.background:
+            response.background = sub_response.background
+
+        if sub_response.status_code:
+            response.status_code = sub_response.status_code
+
+        return response

{strawberry_graphql-0.168.2 → strawberry_graphql-0.170.0}/strawberry/asgi/handlers/__init__.py

@@ -2,6 +2,5 @@ from strawberry.asgi.handlers.graphql_transport_ws_handler import (
     GraphQLTransportWSHandler,
 )
 from strawberry.asgi.handlers.graphql_ws_handler import GraphQLWSHandler
-from strawberry.asgi.handlers.http_handler import HTTPHandler
 
-__all__ = ["GraphQLTransportWSHandler", "GraphQLWSHandler", "HTTPHandler"]
+__all__ = ["GraphQLTransportWSHandler", "GraphQLWSHandler"]

strawberry_graphql-0.170.0/strawberry/chalice/views.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, Mapping, Optional, Union, cast
+
+from chalice.app import Request, Response
+from strawberry.http.exceptions import HTTPException
+from strawberry.http.sync_base_view import SyncBaseHTTPView, SyncHTTPRequestAdapter
+from strawberry.http.temporal_response import TemporalResponse
+from strawberry.http.types import HTTPMethod, QueryParams
+from strawberry.http.typevars import Context, RootValue
+from strawberry.utils.graphiql import get_graphiql_html
+
+if TYPE_CHECKING:
+    from strawberry.http import GraphQLHTTPResponse
+    from strawberry.schema import BaseSchema
+
+
+class ChaliceHTTPRequestAdapter(SyncHTTPRequestAdapter):
+    def __init__(self, request: Request):
+        self.request = request
+
+    @property
+    def query_params(self) -> QueryParams:
+        return self.request.query_params or {}  # type: ignore
+
+    @property
+    def body(self) -> Union[str, bytes]:
+        return self.request.raw_body
+
+    @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 post_data(self) -> Mapping[str, Union[str, bytes]]:
+        raise NotImplementedError
+
+    @property
+    def files(self) -> Mapping[str, Any]:
+        raise NotImplementedError
+
+    @property
+    def content_type(self) -> Optional[str]:
+        return self.request.headers.get("Content-Type", None)
+
+
+class GraphQLView(
+    SyncBaseHTTPView[Request, Response, TemporalResponse, Context, RootValue]
+):
+    allow_queries_via_get: bool = True
+    request_adapter_class = ChaliceHTTPRequestAdapter
+
+    def __init__(
+        self,
+        schema: BaseSchema,
+        graphiql: bool = True,
+        allow_queries_via_get: bool = True,
+    ):
+        self.graphiql = graphiql
+        self.allow_queries_via_get = allow_queries_via_get
+        self.schema = schema
+
+    def get_root_value(self, request: Request) -> Optional[RootValue]:
+        return None
+
+    def render_graphiql(self, request: Request) -> Response:
+        """
+        Returns a string containing the html for the graphiql webpage. It also caches
+        the result using lru cache.
+        This saves loading from disk each time it is invoked.
+
+        Returns:
+            The GraphiQL html page as a string
+        """
+        return get_graphiql_html(subscription_enabled=False)  # type: ignore
+
+    def get_sub_response(self, request: Request) -> TemporalResponse:
+        return TemporalResponse()
+
+    @staticmethod
+    def error_response(
+        message: str,
+        error_code: str,
+        http_status_code: int,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> Response:
+        """
+        A wrapper for error responses
+        Returns:
+        An errors response
+        """
+        body = {"Code": error_code, "Message": message}
+
+        return Response(body=body, status_code=http_status_code, headers=headers)
+
+    def get_context(self, request: Request, response: TemporalResponse) -> Context:
+        return {"request": request, "response": response}  # type: ignore
+
+    def create_response(
+        self, response_data: GraphQLHTTPResponse, sub_response: TemporalResponse
+    ) -> Response:
+        status_code = 200
+
+        if sub_response.status_code != 200:
+            status_code = sub_response.status_code
+
+        return Response(
+            body=self.encode_json(response_data),
+            status_code=status_code,
+            headers=sub_response.headers,
+        )
+
+    def execute_request(self, request: Request) -> Response:
+        try:
+            return self.run(request=request)
+        except HTTPException as e:
+            error_code_map = {
+                400: "BadRequestError",
+                401: "UnauthorizedError",
+                403: "ForbiddenError",
+                404: "NotFoundError",
+                409: "ConflictError",
+                429: "TooManyRequestsError",
+                500: "ChaliceViewError",
+            }
+
+            return self.error_response(
+                error_code=error_code_map.get(e.status_code, "ChaliceViewError"),
+                message=e.reason,
+                http_status_code=e.status_code,
+            )

{strawberry_graphql-0.168.2 → strawberry_graphql-0.170.0}/strawberry/cli/debug_server.py

@@ -1,4 +1,5 @@
 import os
+from typing import Any
 
 from starlette.applications import Starlette
 from starlette.middleware.cors import CORSMiddleware
@@ -21,7 +22,7 @@ schema_symbol = import_module_symbol(schema_import_string, default_symbol_name="
 log_operations = os.environ[DEBUG_SERVER_LOG_OPERATIONS] == "True"
 
 assert isinstance(schema_symbol, Schema)
-graphql_app = GraphQL(schema_symbol, debug=log_operations)
+graphql_app = GraphQL[Any, Any](schema_symbol, debug=log_operations)
 
 paths = ["/", "/graphql"]
 for path in paths: