strawberry-graphql 0.237.2__tar.gz → 0.238.0__tar.gz

{strawberry_graphql-0.237.2 → strawberry_graphql-0.238.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.237.2
+Version: 0.238.0
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT
@@ -35,7 +35,6 @@ Provides-Extra: pydantic
 Provides-Extra: pyinstrument
 Provides-Extra: quart
 Provides-Extra: sanic
-Provides-Extra: starlite
 Requires-Dist: Django (>=3.2) ; extra == "django"
 Requires-Dist: aiohttp (>=3.7.4.post0,<4.0.0) ; extra == "aiohttp"
 Requires-Dist: asgiref (>=3.2,<4.0) ; extra == "django" or extra == "channels"
@@ -59,7 +58,6 @@ Requires-Dist: quart (>=0.19.3) ; extra == "quart"
 Requires-Dist: rich (>=12.0.0) ; extra == "debug" or extra == "debug-server" or extra == "cli"
 Requires-Dist: sanic (>=20.12.2) ; extra == "sanic"
 Requires-Dist: starlette (>=0.18.0) ; extra == "asgi" or extra == "debug-server"
-Requires-Dist: starlite (>=1.48.0) ; (python_version >= "3.8") and (extra == "starlite")
 Requires-Dist: typer (>=0.7.0) ; extra == "debug-server" or extra == "cli"
 Requires-Dist: typing-extensions (>=4.5.0)
 Requires-Dist: uvicorn (>=0.11.6) ; extra == "debug-server"

{strawberry_graphql-0.237.2 → strawberry_graphql-0.238.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.237.2"
+version = "0.238.0"
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "MIT"
@@ -54,7 +54,6 @@ python-multipart = {version = ">=0.0.7", optional = true}
 sanic = {version = ">=20.12.2", optional = true}
 aiohttp = {version = "^3.7.4.post0", optional = true}
 fastapi = {version = ">=0.65.2", optional = true}
-starlite = {version = ">=1.48.0", optional = true, python = ">=3.8"}
 litestar = {version = ">=2", optional = true, python = ">=3.8"}
 channels = {version = ">=3.0.5", optional = true}
 astunparse = {version = "^1.6.3", python = "<3.9"}
@@ -70,7 +69,7 @@ email-validator = {version = ">=1.1.3,<3.0.0", optional = false}
 freezegun = "^1.2.1"
 libcst = {version = ">=1.0.0", optional = false}
 MarkupSafe = "2.1.3"
-nox = "^2023.4.22"
+nox = "^2024.4.15"
 nox-poetry = "^1.0.3"
 opentelemetry-api = "<2"
 opentelemetry-sdk = "<2"
@@ -120,7 +119,6 @@ pytest-aiohttp = "^1.0.3"
 pytest-django = {version = "^4.5"}
 sanic = ">=20.12.2"
 starlette = ">=0.13.6"
-starlite = {version = ">=1.48.0", optional = false, python = ">=3.8", extras = ["testing"]}
 litestar = {version = ">=2", optional = false, python = ">=3.8"}
 uvicorn = ">=0.11.6"
 daphne = "^4.0.0"
@@ -140,7 +138,6 @@ sanic = ["sanic"]
 fastapi = ["fastapi", "python-multipart"]
 chalice = ["chalice"]
 cli = ["typer", "pygments", "rich", "libcst", "graphlib_backport"]
-starlite = ["starlite"]
 litestar = ["litestar"]
 pyinstrument = ["pyinstrument"]
 
@@ -166,7 +163,6 @@ markers = [
     "relay",
     "sanic",
     "starlette",
-    "starlite",
 ]
 asyncio_mode = "auto"
 filterwarnings = [

{strawberry_graphql-0.237.2 → strawberry_graphql-0.238.0}/strawberry/aiohttp/views.py

@@ -15,6 +15,7 @@ from typing import (
 )
 
 from aiohttp import web
+from aiohttp.multipart import BodyPartReader
 from strawberry.aiohttp.handlers import (
     GraphQLTransportWSHandler,
     GraphQLWSHandler,
@@ -60,6 +61,7 @@ class AioHTTPRequestAdapter(AsyncHTTPRequestAdapter):
         files: Dict[str, Any] = {}
 
         async for field in reader:
+            assert isinstance(field, BodyPartReader)
             assert field.name
 
             if field.filename:

{strawberry_graphql-0.237.2 → strawberry_graphql-0.238.0}/strawberry/asgi/__init__.py

@@ -117,12 +117,12 @@ class GraphQL(
         else:
             self.graphql_ide = graphql_ide
 
-    async def __call__(self, scope: Request, receive: Receive, send: Send) -> None:
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
         if scope["type"] == "http":
-            return await self.handle_http(scope, receive, send)  # type: ignore
+            return await self.handle_http(scope, receive, send)
 
         elif scope["type"] == "websocket":
-            ws = WebSocket(scope, receive=receive, send=send)  # type: ignore
+            ws = WebSocket(scope, receive=receive, send=send)
             preferred_protocol = self.pick_preferred_protocol(ws)
 
             if preferred_protocol == GRAPHQL_TRANSPORT_WS_PROTOCOL:

{strawberry_graphql-0.237.2 → strawberry_graphql-0.238.0}/strawberry/extensions/tracing/sentry.py

@@ -24,7 +24,7 @@ class SentryTracingExtension(SchemaExtension):
         execution_context: Optional[ExecutionContext] = None,
     ) -> None:
         warnings.warn(
-            "The Sentry tracing extension is deprecated, please update to sentry>=1.32.0",
+            "The Sentry tracing extension is deprecated, please update to sentry-sdk>=1.32.0",
             DeprecationWarning,
             stacklevel=2,
         )

strawberry_graphql-0.237.2/strawberry/starlite/__init__.py

@@ -1,3 +0,0 @@
-from strawberry.starlite.controller import BaseContext, make_graphql_controller
-
-__all__ = ["BaseContext", "make_graphql_controller"]

strawberry_graphql-0.237.2/strawberry/starlite/controller.py

@@ -1,387 +0,0 @@
-"""Starlite integration for strawberry-graphql."""
-
-from __future__ import annotations
-
-import warnings
-from dataclasses import dataclass
-from datetime import timedelta
-from typing import TYPE_CHECKING, Any, Dict, Mapping, Optional, Tuple, Union, cast
-from typing_extensions import deprecated
-
-from starlite import (
-    BackgroundTasks,
-    Controller,
-    MediaType,
-    Provide,
-    Request,
-    Response,
-    WebSocket,
-    get,
-    post,
-    websocket,
-)
-from starlite.exceptions import (
-    NotFoundException,
-    ValidationException,
-)
-from starlite.status_codes import HTTP_200_OK
-from strawberry.exceptions import InvalidCustomContext
-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.subscriptions.protocols.graphql_transport_ws import (
-    WS_4406_PROTOCOL_NOT_ACCEPTABLE,
-)
-
-from .handlers.graphql_transport_ws_handler import (
-    GraphQLTransportWSHandler as BaseGraphQLTransportWSHandler,
-)
-from .handlers.graphql_ws_handler import GraphQLWSHandler as BaseGraphQLWSHandler
-
-if TYPE_CHECKING:
-    from typing import FrozenSet, List, Type
-
-    from starlite.types import AnyCallable, Dependencies
-    from strawberry.http import GraphQLHTTPResponse
-    from strawberry.http.ides import GraphQL_IDE
-    from strawberry.schema import BaseSchema
-
-    MergedContext = Union[
-        "BaseContext",
-        Union[
-            Dict[str, Any],
-            Dict[str, BackgroundTasks],
-            Dict[str, Request[Any, Any]],
-            Dict[str, Response[Any]],
-            Dict[str, websocket],
-        ],
-    ]
-
-CustomContext = Union["BaseContext", Dict[str, Any]]
-
-
-async def _context_getter(
-    custom_context: Optional[CustomContext],
-    request: Request[Any, Any],
-    response: Response[Any],
-) -> MergedContext:
-    if isinstance(custom_context, BaseContext):
-        custom_context.request = request
-        return custom_context
-
-    default_context = {
-        "request": request,
-        "response": response,
-    }
-
-    if isinstance(custom_context, dict):
-        return {
-            **default_context,
-            **custom_context,
-        }
-
-    if custom_context is None:
-        return default_context
-
-    raise InvalidCustomContext()
-
-
-@dataclass
-class GraphQLResource:
-    data: Optional[Dict[str, object]]
-    errors: Optional[List[object]]
-    extensions: Optional[Dict[str, object]]
-
-
-@dataclass
-class EmptyResponseModel:
-    pass
-
-
-class GraphQLWSHandler(BaseGraphQLWSHandler):
-    async def get_context(self) -> Any:
-        return await self._get_context()
-
-    async def get_root_value(self) -> Any:
-        return await self._get_root_value()
-
-
-class GraphQLTransportWSHandler(BaseGraphQLTransportWSHandler):
-    async def get_context(self) -> Any:
-        return await self._get_context()
-
-    async def get_root_value(self) -> Any:
-        return await self._get_root_value()
-
-
-@deprecated(
-    "The `starlite` integration is deprecated in favor of `litestar` integration",
-    stacklevel=2,
-)
-class StarliteRequestAdapter(AsyncHTTPRequestAdapter):
-    def __init__(self, request: Request[Any, Any]) -> 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.content_type[0]
-
-    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(form=multipart_data, files=multipart_data)
-
-
-class BaseContext:
-    def __init__(self) -> None:
-        self.request: Optional[Union[Request, WebSocket]] = None
-        self.response: Optional[Response] = None
-
-
-@deprecated(
-    "The `starlite` integration is deprecated in favor of `litestar` integration",
-    stacklevel=2,
-)
-def make_graphql_controller(
-    schema: BaseSchema,
-    path: str = "",
-    graphiql: Optional[bool] = None,
-    graphql_ide: Optional[GraphQL_IDE] = "graphiql",
-    allow_queries_via_get: bool = True,
-    keep_alive: bool = False,
-    keep_alive_interval: float = 1,
-    debug: bool = False,
-    # TODO: root typevar
-    root_value_getter: Optional[AnyCallable] = None,
-    # TODO: context typevar
-    context_getter: Optional[AnyCallable] = None,
-    subscription_protocols: Tuple[str, ...] = (
-        GRAPHQL_TRANSPORT_WS_PROTOCOL,
-        GRAPHQL_WS_PROTOCOL,
-    ),
-    connection_init_wait_timeout: timedelta = timedelta(minutes=1),
-) -> Type[Controller]:
-    routes_path = path
-
-    if context_getter is None:
-
-        def custom_context_getter_() -> None:
-            return None
-
-    else:
-        custom_context_getter_ = context_getter
-
-    if root_value_getter is None:
-
-        def root_value_getter_() -> None:
-            return None
-
-    else:
-        root_value_getter_ = root_value_getter
-
-    def response_getter() -> Response[Any]:
-        return Response({}, background=BackgroundTasks([]))
-
-    schema_ = schema
-    allow_queries_via_get_ = allow_queries_via_get
-    graphql_ide_: Optional[GraphQL_IDE]
-
-    if graphiql is not None:
-        warnings.warn(
-            "The `graphiql` argument is deprecated in favor of `graphql_ide`",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        graphql_ide_ = "graphiql" if graphiql else None
-    else:
-        graphql_ide_ = graphql_ide
-
-    class GraphQLController(
-        Controller,
-        AsyncBaseHTTPView[
-            Request[Any, Any], Response[Any], Response[Any], Context, RootValue
-        ],
-    ):
-        request_adapter_class = StarliteRequestAdapter
-        path: str = routes_path
-        dependencies: Optional[Dependencies] = {
-            "custom_context": Provide(custom_context_getter_),
-            "context": Provide(_context_getter),
-            "root_value": Provide(root_value_getter_),
-            "response": Provide(response_getter),
-        }
-        graphql_ws_handler_class: Type[GraphQLWSHandler] = GraphQLWSHandler
-        graphql_transport_ws_handler_class: Type[GraphQLTransportWSHandler] = (
-            GraphQLTransportWSHandler
-        )
-
-        _keep_alive: bool = keep_alive
-        _keep_alive_interval: float = keep_alive_interval
-        _debug: bool = debug
-        _protocols: Tuple[str, ...] = subscription_protocols
-        _connection_init_wait_timeout: timedelta = connection_init_wait_timeout
-        _graphiql_allowed_accept: FrozenSet[str] = frozenset({"text/html", "*/*"})
-
-        schema: BaseSchema = schema_
-        allow_queries_via_get = allow_queries_via_get_
-        graphql_ide = graphql_ide_
-
-        async def execute_request(
-            self,
-            request: Request[Any, Any],
-            context: CustomContext,
-            root_value: Any,
-        ) -> Response[Union[GraphQLResource, str]]:
-            try:
-                return await self.run(
-                    request,
-                    # TODO: check the dependency, above, can we make it so that
-                    # we don't need to type ignore here?
-                    context=context,  # type: ignore
-                    root_value=root_value,
-                )
-            except HTTPException as e:
-                return Response(
-                    e.reason,
-                    status_code=e.status_code,
-                    media_type=MediaType.TEXT,
-                )
-
-        async def render_graphql_ide(self, request: Request[Any, Any]) -> Response[str]:
-            return Response(self.graphql_ide_html, media_type=MediaType.HTML)
-
-        def create_response(
-            self, response_data: GraphQLHTTPResponse, sub_response: Response[bytes]
-        ) -> Response[bytes]:
-            response = Response(
-                self.encode_json(response_data).encode(),
-                status_code=HTTP_200_OK,
-                media_type=MediaType.JSON,
-            )
-
-            response.headers.update(sub_response.headers)
-            response.cookies.extend(sub_response.cookies)
-            response.background = sub_response.background
-
-            if sub_response.status_code:
-                response.status_code = sub_response.status_code
-
-            return response
-
-        @get(raises=[ValidationException, NotFoundException])
-        async def handle_http_get(
-            self,
-            request: Request[Any, Any],
-            context: CustomContext,
-            root_value: Any,
-            response: Response[Any],
-        ) -> Response[Union[GraphQLResource, str]]:
-            self.temporal_response = response
-
-            return await self.execute_request(
-                request=request,
-                context=context,
-                root_value=root_value,
-            )
-
-        @post(status_code=HTTP_200_OK)
-        async def handle_http_post(
-            self,
-            request: Request[Any, Any],
-            context: CustomContext,
-            root_value: Any,
-            response: Response[Any],
-        ) -> Response[Union[GraphQLResource, str]]:
-            self.temporal_response = response
-
-            return await self.execute_request(
-                request=request,
-                context=context,
-                root_value=root_value,
-            )
-
-        async def get_context(
-            self, request: Request[Any, Any], response: Response[Any]
-        ) -> Context:  # pragma: no cover
-            raise ValueError("`get_context` is not used by Starlite's controller")
-
-        async def get_root_value(
-            self, request: Request[Any, Any]
-        ) -> Optional[RootValue]:  # pragma: no cover
-            raise ValueError("`get_root_value` is not used by Starlite's controller")
-
-        async def get_sub_response(self, request: Request[Any, Any]) -> Response[Any]:
-            return self.temporal_response
-
-        @websocket()
-        async def websocket_endpoint(
-            self,
-            socket: WebSocket,
-            context: CustomContext,
-            root_value: Any,
-        ) -> None:
-            async def _get_context() -> CustomContext:
-                return context
-
-            async def _get_root_value() -> Any:
-                return root_value
-
-            preferred_protocol = self.pick_preferred_protocol(socket)
-            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=_get_context,
-                    get_root_value=_get_root_value,
-                    ws=socket,
-                ).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=_get_context,
-                    get_root_value=_get_root_value,
-                    ws=socket,
-                ).handle()
-            else:
-                await socket.close(code=WS_4406_PROTOCOL_NOT_ACCEPTABLE)
-
-        def pick_preferred_protocol(self, socket: WebSocket) -> Optional[str]:
-            protocols: List[str] = socket.scope["subprotocols"]
-            intersection = set(protocols) & set(self._protocols)
-            return (
-                min(
-                    intersection,
-                    key=lambda i: protocols.index(i) if i else "",
-                    default=None,
-                )
-                or None
-            )
-
-    return GraphQLController
-
-
-__all__ = ["make_graphql_controller"]

strawberry_graphql-0.237.2/strawberry/starlite/handlers/graphql_transport_ws_handler.py

@@ -1,59 +0,0 @@
-from datetime import timedelta
-from typing import Any, Callable
-
-from starlite import WebSocket
-from starlite.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_graphql-0.237.2/strawberry/starlite/handlers/graphql_ws_handler.py

@@ -1,64 +0,0 @@
-from contextlib import suppress
-from typing import Any, Callable, Optional
-
-from starlite import WebSocket
-from starlite.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
-                    # Ignore non-text messages
-                    continue
-                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"]