strawberry-graphql 0.279.0.dev1754156227__py3-none-any.whl → 0.280.0__py3-none-any.whl

strawberry/__init__.py

@@ -4,7 +4,7 @@ Strawberry is a Python library for GraphQL that aims to stay close to the GraphQ
 specification and allow for a more natural way of defining GraphQL schemas.
 """
 
-from . import experimental, federation, pydantic, relay
+from . import experimental, federation, relay
 from .directive import directive, directive_field
 from .parent import Parent
 from .permission import BasePermission
@@ -54,7 +54,6 @@ __all__ = [
     "interface",
     "lazy",
     "mutation",
-    "pydantic",
     "relay",
     "scalar",
     "schema_directive",

strawberry/aiohttp/views.py

@@ -3,32 +3,27 @@ from __future__ import annotations
 import asyncio
 import warnings
 from datetime import timedelta
-from io import BytesIO
 from json.decoder import JSONDecodeError
 from typing import (
     TYPE_CHECKING,
-    Any,
     Callable,
     Optional,
     Union,
-    cast,
 )
 from typing_extensions import TypeGuard
 
+from lia import AiohttpHTTPRequestAdapter, HTTPException
+
 from aiohttp import ClientConnectionResetError, http, web
-from aiohttp.multipart import BodyPartReader
 from strawberry.http.async_base_view import (
     AsyncBaseHTTPView,
-    AsyncHTTPRequestAdapter,
     AsyncWebSocketAdapter,
 )
 from strawberry.http.exceptions import (
-    HTTPException,
     NonJsonMessageReceived,
     NonTextMessageReceived,
     WebSocketDisconnected,
 )
-from strawberry.http.types import FormData, HTTPMethod, QueryParams
 from strawberry.http.typevars import (
     Context,
     RootValue,
@@ -43,47 +38,6 @@ if TYPE_CHECKING:
     from strawberry.schema import BaseSchema
 
 
-class AiohttpHTTPRequestAdapter(AsyncHTTPRequestAdapter):
-    def __init__(self, request: web.Request) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        return self.request.query.copy()  # type: ignore[attr-defined]
-
-    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] = {}
-
-        while field := await reader.next():
-            assert isinstance(field, BodyPartReader)
-            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.headers.get("content-type")
-
-
 class AiohttpWebSocketAdapter(AsyncWebSocketAdapter):
     def __init__(
         self, view: AsyncBaseHTTPView, request: web.Request, ws: web.WebSocketResponse

strawberry/asgi/__init__.py

@@ -8,10 +8,10 @@ from typing import (
     Callable,
     Optional,
     Union,
-    cast,
 )
 from typing_extensions import TypeGuard
 
+from lia import HTTPException, StarletteRequestAdapter
 from starlette import status
 from starlette.requests import Request
 from starlette.responses import (
@@ -24,16 +24,13 @@ from starlette.websockets import WebSocket, WebSocketDisconnect, WebSocketState
 
 from strawberry.http.async_base_view import (
     AsyncBaseHTTPView,
-    AsyncHTTPRequestAdapter,
     AsyncWebSocketAdapter,
 )
 from strawberry.http.exceptions import (
-    HTTPException,
     NonJsonMessageReceived,
     NonTextMessageReceived,
     WebSocketDisconnected,
 )
-from strawberry.http.types import FormData, HTTPMethod, QueryParams
 from strawberry.http.typevars import (
     Context,
     RootValue,
@@ -50,38 +47,6 @@ if TYPE_CHECKING:
     from strawberry.schema import BaseSchema
 
 
-class ASGIRequestAdapter(AsyncHTTPRequestAdapter):
-    def __init__(self, request: Request) -> 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.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 ASGIWebSocketAdapter(AsyncWebSocketAdapter):
     def __init__(
         self, view: AsyncBaseHTTPView, request: WebSocket, response: WebSocket
@@ -127,7 +92,7 @@ class GraphQL(
     ]
 ):
     allow_queries_via_get = True
-    request_adapter_class = ASGIRequestAdapter
+    request_adapter_class = StarletteRequestAdapter
     websocket_adapter_class = ASGIWebSocketAdapter
 
     def __init__(

strawberry/chalice/views.py

@@ -1,56 +1,21 @@
 from __future__ import annotations
 
 import warnings
-from typing import TYPE_CHECKING, Any, Optional, Union, cast
+from typing import TYPE_CHECKING, Optional, Union
+
+from lia import ChaliceHTTPRequestAdapter, HTTPException
 
 from chalice.app import Request, Response
-from strawberry.http.exceptions import HTTPException
-from strawberry.http.sync_base_view import SyncBaseHTTPView, SyncHTTPRequestAdapter
+from strawberry.http.sync_base_view import SyncBaseHTTPView
 from strawberry.http.temporal_response import TemporalResponse
 from strawberry.http.typevars import Context, RootValue
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping
-
     from strawberry.http import GraphQLHTTPResponse
     from strawberry.http.ides import GraphQL_IDE
-    from strawberry.http.types import HTTPMethod, QueryParams
     from strawberry.schema import BaseSchema
 
 
-class ChaliceHTTPRequestAdapter(SyncHTTPRequestAdapter):
-    def __init__(self, request: Request) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        return self.request.query_params or {}
-
-    @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]
 ):
@@ -88,28 +53,6 @@ class GraphQLView(
     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 | list[str]]] = None,
-    ) -> Response:
-        """A wrapper for error responses.
-
-        Args:
-            message: The error message.
-            error_code: The error code.
-            http_status_code: The HTTP status code.
-            headers: The headers to include in the response.
-
-        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
 
@@ -136,20 +79,9 @@ class GraphQLView(
         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,
+            return Response(
+                body=e.reason,
+                status_code=e.status_code,
             )
 
 

strawberry/channels/handlers/http_handler.py

@@ -12,14 +12,13 @@ from urllib.parse import parse_qs
 from django.conf import settings
 from django.core.files import uploadhandler
 from django.http.multipartparser import MultiPartParser
+from lia import AsyncHTTPRequestAdapter, FormData, HTTPException, SyncHTTPRequestAdapter
 
 from channels.db import database_sync_to_async
 from channels.generic.http import AsyncHttpConsumer
-from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncHTTPRequestAdapter
-from strawberry.http.exceptions import HTTPException
-from strawberry.http.sync_base_view import SyncBaseHTTPView, SyncHTTPRequestAdapter
+from strawberry.http.async_base_view import AsyncBaseHTTPView
+from strawberry.http.sync_base_view import SyncBaseHTTPView
 from strawberry.http.temporal_response import TemporalResponse
-from strawberry.http.types import FormData
 from strawberry.http.typevars import Context, RootValue
 from strawberry.types.unset import UNSET
 
@@ -127,6 +126,28 @@ class BaseChannelsRequestAdapter:
     def content_type(self) -> Optional[str]:
         return self.request.content_type
 
+    @property
+    def url(self) -> str:
+        scheme = self.request.consumer.scope["scheme"]
+        host = self.headers.get("host", "localhost")
+        path = self.request.consumer.scope["path"]
+        query_string = self.request.consumer.scope["query_string"]
+        url = f"{scheme}://{host}{path}"
+        if query_string:
+            url += f"?{query_string.decode()}"
+        return url
+
+    @property
+    def cookies(self) -> Mapping[str, str]:
+        cookie_header = self.headers.get("cookie", "")
+        cookies = {}
+        if cookie_header:
+            for cookie in cookie_header.split(";"):
+                if "=" in cookie:
+                    key, value = cookie.split("=", 1)
+                    cookies[key.strip()] = value.strip()
+        return cookies
+
 
 class ChannelsRequestAdapter(BaseChannelsRequestAdapter, AsyncHTTPRequestAdapter):
     async def get_body(self) -> bytes:
@@ -143,11 +164,14 @@ class SyncChannelsRequestAdapter(BaseChannelsRequestAdapter, SyncHTTPRequestAdap
 
     @property
     def post_data(self) -> Mapping[str, Union[str, bytes]]:
-        return self.request.form_data["form"]
+        return self.request.form_data.form
 
     @property
     def files(self) -> Mapping[str, Any]:
-        return self.request.form_data["files"]
+        return self.request.form_data.files
+
+    def get_form_data(self) -> FormData:
+        return self.request.form_data
 
 
 class BaseGraphQLHTTPConsumer(ChannelsConsumer, AsyncHttpConsumer):

strawberry/cli/commands/upgrade/__init__.py

@@ -10,6 +10,7 @@ from libcst.codemod import CodemodContext
 
 from strawberry.cli.app import app
 from strawberry.codemods.annotated_unions import ConvertUnionToAnnotatedUnion
+from strawberry.codemods.maybe_optional import ConvertMaybeToOptional
 from strawberry.codemods.update_imports import UpdateImportsCodemod
 
 from ._run_codemod import run_codemod
@@ -17,6 +18,7 @@ from ._run_codemod import run_codemod
 codemods = {
     "annotated-union": ConvertUnionToAnnotatedUnion,
     "update-imports": UpdateImportsCodemod,
+    "maybe-optional": ConvertMaybeToOptional,
 }
 
 

strawberry/codemods/__init__.py

@@ -0,0 +1,9 @@
+from .annotated_unions import ConvertUnionToAnnotatedUnion
+from .maybe_optional import ConvertMaybeToOptional
+from .update_imports import UpdateImportsCodemod
+
+__all__ = [
+    "ConvertMaybeToOptional",
+    "ConvertUnionToAnnotatedUnion",
+    "UpdateImportsCodemod",
+]

strawberry/codemods/maybe_optional.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import libcst as cst
+import libcst.matchers as m
+from libcst._nodes.expression import BaseExpression  # noqa: TC002
+from libcst.codemod import CodemodContext, VisitorBasedCodemodCommand
+from libcst.codemod.visitors import AddImportsVisitor
+
+
+class ConvertMaybeToOptional(VisitorBasedCodemodCommand):
+    DESCRIPTION: str = (
+        "Converts strawberry.Maybe[T] to strawberry.Maybe[T | None] "
+        "to match the new Maybe type definition"
+    )
+
+    def __init__(
+        self,
+        context: CodemodContext,
+        use_pipe_syntax: bool = True,  # Default to pipe syntax for modern Python
+    ) -> None:
+        self.use_pipe_syntax = use_pipe_syntax
+        super().__init__(context)
+
+    @m.leave(
+        m.Subscript(
+            value=m.Attribute(value=m.Name("strawberry"), attr=m.Name("Maybe"))
+            | m.Name("Maybe")
+        )
+    )
+    def leave_maybe_subscript(
+        self, original_node: cst.Subscript, updated_node: cst.Subscript
+    ) -> BaseExpression:
+        # Skip if it's not a strawberry.Maybe or imported Maybe
+        if isinstance(original_node.value, cst.Name):
+            # Check if this is an imported Maybe from strawberry
+            # For now, we'll assume any standalone "Maybe" is from strawberry
+            # In a more robust implementation, we'd track imports
+            pass
+
+        # Get the inner type
+        if isinstance(original_node.slice, (list, tuple)):
+            if len(original_node.slice) != 1:
+                return original_node
+            slice_element = original_node.slice[0]
+        else:
+            slice_element = original_node.slice
+
+        if not isinstance(slice_element, cst.SubscriptElement):
+            return original_node
+
+        if not isinstance(slice_element.slice, cst.Index):
+            return original_node
+
+        inner_type = slice_element.slice.value
+
+        # Check if the inner type already includes None
+        if self._already_includes_none(inner_type):
+            return original_node
+
+        # Create the new union type with None
+        new_type: BaseExpression
+        if self.use_pipe_syntax:
+            new_type = cst.BinaryOperation(
+                left=inner_type,
+                operator=cst.BitOr(
+                    whitespace_before=cst.SimpleWhitespace(" "),
+                    whitespace_after=cst.SimpleWhitespace(" "),
+                ),
+                right=cst.Name("None"),
+            )
+        else:
+            # Use Union[T, None] syntax
+            AddImportsVisitor.add_needed_import(self.context, "typing", "Union")
+            new_type = cst.Subscript(
+                value=cst.Name("Union"),
+                slice=[
+                    cst.SubscriptElement(slice=cst.Index(value=inner_type)),
+                    cst.SubscriptElement(slice=cst.Index(value=cst.Name("None"))),
+                ],
+            )
+
+        # Return the updated Maybe[T | None]
+        return updated_node.with_changes(
+            slice=[cst.SubscriptElement(slice=cst.Index(value=new_type))]
+        )
+
+    def _already_includes_none(self, node: BaseExpression) -> bool:
+        """Check if the type already includes None (e.g., T | None or Union[T, None])."""
+        # Check for T | None pattern
+        if isinstance(node, cst.BinaryOperation) and isinstance(
+            node.operator, cst.BitOr
+        ):
+            if isinstance(node.right, cst.Name) and node.right.value == "None":
+                return True
+            # Recursively check left side for chained unions
+            if self._already_includes_none(node.left):
+                return True
+
+        # Check for Union[..., None] pattern
+        if (
+            isinstance(node, cst.Subscript)
+            and isinstance(node.value, cst.Name)
+            and node.value.value == "Union"
+        ):
+            # Handle both list and tuple slice formats
+            slice_elements = (
+                node.slice if isinstance(node.slice, (list, tuple)) else [node.slice]
+            )
+            for element in slice_elements:
+                if (
+                    isinstance(element, cst.SubscriptElement)
+                    and isinstance(element.slice, cst.Index)
+                    and isinstance(element.slice.value, cst.Name)
+                    and element.slice.value.value == "None"
+                ):
+                    return True
+
+        return False

strawberry/django/views.py

@@ -8,7 +8,6 @@ from typing import (
     Callable,
     Optional,
     Union,
-    cast,
 )
 from typing_extensions import TypeGuard
 
@@ -26,11 +25,10 @@ from django.template.exceptions import TemplateDoesNotExist
 from django.template.loader import render_to_string
 from django.utils.decorators import classonlymethod
 from django.views.generic import View
+from lia import AsyncDjangoHTTPRequestAdapter, DjangoHTTPRequestAdapter, HTTPException
 
-from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncHTTPRequestAdapter
-from strawberry.http.exceptions import HTTPException
-from strawberry.http.sync_base_view import SyncBaseHTTPView, SyncHTTPRequestAdapter
-from strawberry.http.types import FormData, HTTPMethod, QueryParams
+from strawberry.http.async_base_view import AsyncBaseHTTPView
+from strawberry.http.sync_base_view import SyncBaseHTTPView
 from strawberry.http.typevars import (
     Context,
     RootValue,
@@ -39,7 +37,7 @@ from strawberry.http.typevars import (
 from .context import StrawberryDjangoContext
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncIterator, Mapping
+    from collections.abc import AsyncIterator
 
     from django.template.response import TemplateResponse
 
@@ -67,73 +65,6 @@ class TemporalHttpResponse(JsonResponse):
         )
 
 
-class DjangoHTTPRequestAdapter(SyncHTTPRequestAdapter):
-    def __init__(self, request: HttpRequest) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        return self.request.GET.dict()
-
-    @property
-    def body(self) -> Union[str, bytes]:
-        return self.request.body.decode()
-
-    @property
-    def method(self) -> HTTPMethod:
-        assert self.request.method is not None
-
-        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]]:
-        return self.request.POST
-
-    @property
-    def files(self) -> Mapping[str, Any]:
-        return self.request.FILES
-
-    @property
-    def content_type(self) -> Optional[str]:
-        return self.request.content_type
-
-
-class AsyncDjangoHTTPRequestAdapter(AsyncHTTPRequestAdapter):
-    def __init__(self, request: HttpRequest) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        return self.request.GET.dict()
-
-    @property
-    def method(self) -> HTTPMethod:
-        assert self.request.method is not None
-
-        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.headers.get("Content-type")
-
-    async def get_body(self) -> str:
-        return self.request.body.decode()
-
-    async def get_form_data(self) -> FormData:
-        return FormData(
-            files=self.request.FILES,
-            form=self.request.POST,
-        )
-
-
 class BaseView:
     graphql_ide_html: str
 

strawberry/experimental/pydantic/_compat.py

@@ -8,6 +8,7 @@ from uuid import UUID
 import pydantic
 from pydantic import BaseModel
 from pydantic.version import VERSION as PYDANTIC_VERSION
+
 from strawberry.experimental.pydantic.exceptions import UnsupportedTypeError
 
 if TYPE_CHECKING:

strawberry/experimental/pydantic/error_type.py

@@ -12,6 +12,7 @@ from typing import (
 )
 
 from pydantic import BaseModel
+
 from strawberry.experimental.pydantic._compat import (
     CompatModelField,
     PydanticCompat,

strawberry/experimental/pydantic/fields.py

@@ -2,6 +2,7 @@ import builtins
 from typing import Annotated, Any, Union
 
 from pydantic import BaseModel
+
 from strawberry.experimental.pydantic._compat import (
     PydanticCompat,
     get_args,

strawberry/experimental/pydantic/utils.py

@@ -10,6 +10,7 @@ from typing import (
 )
 
 from pydantic import BaseModel
+
 from strawberry.experimental.pydantic._compat import (
     CompatModelField,
     PydanticCompat,

strawberry/fastapi/router.py

@@ -13,6 +13,7 @@ from typing import (
 )
 from typing_extensions import TypeGuard
 
+from lia import HTTPException, StarletteRequestAdapter
 from starlette import status
 from starlette.background import BackgroundTasks  # noqa: TC002
 from starlette.requests import HTTPConnection, Request
@@ -29,16 +30,19 @@ from fastapi import APIRouter, Depends, params
 from fastapi.datastructures import Default
 from fastapi.routing import APIRoute
 from fastapi.utils import generate_unique_id
-from strawberry.asgi import ASGIRequestAdapter, ASGIWebSocketAdapter
+from strawberry.asgi import ASGIWebSocketAdapter
 from strawberry.exceptions import InvalidCustomContext
 from strawberry.fastapi.context import BaseContext, CustomContext
 from strawberry.http.async_base_view import AsyncBaseHTTPView
-from strawberry.http.exceptions import HTTPException
 from strawberry.http.typevars import Context, RootValue
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncIterator, Awaitable, Sequence
+    from collections.abc import (
+        AsyncIterator,
+        Awaitable,
+        Sequence,
+    )
     from enum import Enum
 
     from starlette.routing import BaseRoute
@@ -57,7 +61,7 @@ class GraphQLRouter(
     APIRouter,
 ):
     allow_queries_via_get = True
-    request_adapter_class = ASGIRequestAdapter
+    request_adapter_class = StarletteRequestAdapter
     websocket_adapter_class = ASGIWebSocketAdapter
 
     @staticmethod