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

strawberry/flask/views.py

@@ -3,67 +3,27 @@ from __future__ import annotations
 import warnings
 from typing import (
     TYPE_CHECKING,
-    Any,
     ClassVar,
     Optional,
     Union,
-    cast,
 )
 from typing_extensions import TypeGuard
 
+from lia import AsyncFlaskHTTPRequestAdapter, FlaskHTTPRequestAdapter, HTTPException
+
 from flask import Request, Response, render_template_string, request
 from flask.views import View
-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
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping
-
     from flask.typing import ResponseReturnValue
     from strawberry.http import GraphQLHTTPResponse
     from strawberry.http.ides import GraphQL_IDE
     from strawberry.schema.base import BaseSchema
 
 
-class FlaskHTTPRequestAdapter(SyncHTTPRequestAdapter):
-    def __init__(self, request: Request) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        return self.request.args.to_dict()
-
-    @property
-    def body(self) -> Union[str, bytes]:
-        return self.request.data.decode()
-
-    @property
-    def method(self) -> HTTPMethod:
-        return cast("HTTPMethod", self.request.method.upper())
-
-    @property
-    def headers(self) -> Mapping[str, str]:
-        return self.request.headers  # type: ignore
-
-    @property
-    def post_data(self) -> Mapping[str, Union[str, bytes]]:
-        return self.request.form
-
-    @property
-    def files(self) -> Mapping[str, Any]:
-        return self.request.files
-
-    @property
-    def content_type(self) -> Optional[str]:
-        return self.request.content_type
-
-
 class BaseGraphQLView:
     graphql_ide: Optional[GraphQL_IDE]
 
@@ -131,36 +91,6 @@ class GraphQLView(
         return render_template_string(self.graphql_ide_html)  # type: ignore
 
 
-class AsyncFlaskHTTPRequestAdapter(AsyncHTTPRequestAdapter):
-    def __init__(self, request: Request) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        return self.request.args.to_dict()
-
-    @property
-    def method(self) -> HTTPMethod:
-        return cast("HTTPMethod", self.request.method.upper())
-
-    @property
-    def content_type(self) -> Optional[str]:
-        return self.request.content_type
-
-    @property
-    def headers(self) -> Mapping[str, str]:
-        return self.request.headers  # type: ignore
-
-    async def get_body(self) -> str:
-        return self.request.data.decode()
-
-    async def get_form_data(self) -> FormData:
-        return FormData(
-            files=self.request.files,
-            form=self.request.form,
-        )
-
-
 class AsyncGraphQLView(
     BaseGraphQLView,
     AsyncBaseHTTPView[

strawberry/http/async_base_view.py

@@ -17,6 +17,7 @@ from typing import (
 from typing_extensions import TypeGuard
 
 from graphql import GraphQLError
+from lia import AsyncHTTPRequestAdapter, HTTPException
 
 from strawberry.exceptions import MissingQueryError
 from strawberry.file_uploads.utils import replace_placeholders_with_files
@@ -44,9 +45,7 @@ from strawberry.types.graphql import OperationType
 from strawberry.types.unset import UNSET, UnsetType
 
 from .base import BaseView
-from .exceptions import HTTPException
 from .parse_content_type import parse_content_type
-from .types import FormData, HTTPMethod, QueryParams
 from .typevars import (
     Context,
     Request,
@@ -58,30 +57,6 @@ from .typevars import (
 )
 
 
-class AsyncHTTPRequestAdapter(abc.ABC):
-    @property
-    @abc.abstractmethod
-    def query_params(self) -> QueryParams: ...
-
-    @property
-    @abc.abstractmethod
-    def method(self) -> HTTPMethod: ...
-
-    @property
-    @abc.abstractmethod
-    def headers(self) -> Mapping[str, str]: ...
-
-    @property
-    @abc.abstractmethod
-    def content_type(self) -> Optional[str]: ...
-
-    @abc.abstractmethod
-    async def get_body(self) -> Union[str, bytes]: ...
-
-    @abc.abstractmethod
-    async def get_form_data(self) -> FormData: ...
-
-
 class AsyncWebSocketAdapter(abc.ABC):
     def __init__(self, view: "AsyncBaseHTTPView") -> None:
         self.view = view
@@ -284,8 +259,9 @@ class AsyncBaseHTTPView(
         except ValueError as e:
             raise HTTPException(400, "Unable to parse the multipart body") from e
 
-        operations = form_data["form"].get("operations", "{}")
-        files_map = form_data["form"].get("map", "{}")
+        operations = form_data.form.get("operations", "{}")
+        files_map = form_data.form.get("map", "{}")
+        files = form_data.files
 
         if isinstance(operations, (bytes, str)):
             operations = self.parse_json(operations)
@@ -294,9 +270,7 @@ class AsyncBaseHTTPView(
             files_map = self.parse_json(files_map)
 
         try:
-            return replace_placeholders_with_files(
-                operations, files_map, form_data["files"]
-            )
+            return replace_placeholders_with_files(operations, files_map, files)
         except KeyError as e:
             raise HTTPException(400, "File(s) missing in form data") from e
 

strawberry/http/base.py

@@ -3,12 +3,13 @@ from collections.abc import Mapping
 from typing import Any, Generic, Optional, Union
 from typing_extensions import Protocol
 
+from lia import HTTPException
+
 from strawberry.http import GraphQLRequestData
 from strawberry.http.ides import GraphQL_IDE, get_graphql_ide_html
 from strawberry.http.types import HTTPMethod, QueryParams
 from strawberry.schema.base import BaseSchema
 
-from .exceptions import HTTPException
 from .typevars import Request
 
 

strawberry/http/exceptions.py

@@ -1,9 +1,3 @@
-class HTTPException(Exception):
-    def __init__(self, status_code: int, reason: str) -> None:
-        self.status_code = status_code
-        self.reason = reason
-
-
 class NonTextMessageReceived(Exception):
     pass
 
@@ -16,4 +10,8 @@ class WebSocketDisconnected(Exception):
     pass
 
 
-__all__ = ["HTTPException"]
+__all__ = [
+    "NonJsonMessageReceived",
+    "NonTextMessageReceived",
+    "WebSocketDisconnected",
+]

strawberry/http/sync_base_view.py

@@ -1,8 +1,6 @@
 import abc
 import json
-from collections.abc import Mapping
 from typing import (
-    Any,
     Callable,
     Generic,
     Literal,
@@ -11,6 +9,7 @@ from typing import (
 )
 
 from graphql import GraphQLError
+from lia import HTTPException, SyncHTTPRequestAdapter
 
 from strawberry.exceptions import MissingQueryError
 from strawberry.file_uploads.utils import replace_placeholders_with_files
@@ -30,42 +29,10 @@ from strawberry.types.graphql import OperationType
 from strawberry.types.unset import UNSET
 
 from .base import BaseView
-from .exceptions import HTTPException
 from .parse_content_type import parse_content_type
-from .types import HTTPMethod, QueryParams
 from .typevars import Context, Request, Response, RootValue, SubResponse
 
 
-class SyncHTTPRequestAdapter(abc.ABC):
-    @property
-    @abc.abstractmethod
-    def query_params(self) -> QueryParams: ...
-
-    @property
-    @abc.abstractmethod
-    def body(self) -> Union[str, bytes]: ...
-
-    @property
-    @abc.abstractmethod
-    def method(self) -> HTTPMethod: ...
-
-    @property
-    @abc.abstractmethod
-    def headers(self) -> Mapping[str, str]: ...
-
-    @property
-    @abc.abstractmethod
-    def content_type(self) -> Optional[str]: ...
-
-    @property
-    @abc.abstractmethod
-    def post_data(self) -> Mapping[str, Union[str, bytes]]: ...
-
-    @property
-    @abc.abstractmethod
-    def files(self) -> Mapping[str, Any]: ...
-
-
 class SyncBaseHTTPView(
     abc.ABC,
     BaseView[Request],

strawberry/litestar/controller.py

@@ -13,10 +13,10 @@ from typing import (
     Optional,
     TypedDict,
     Union,
-    cast,
 )
 from typing_extensions import TypeGuard
 
+from lia import HTTPException, LitestarRequestAdapter
 from msgspec import Struct
 
 from litestar import (
@@ -41,16 +41,13 @@ from litestar.status_codes import HTTP_200_OK
 from strawberry.exceptions import InvalidCustomContext
 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
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
 
@@ -153,41 +150,6 @@ class GraphQLResource(Struct):
     extensions: Optional[dict[str, object]]
 
 
-class LitestarRequestAdapter(AsyncHTTPRequestAdapter):
-    def __init__(self, request: Request[Any, 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]:
-        content_type, params = self.request.content_type
-
-        # combine content type and params
-        if params:
-            content_type += "; " + "; ".join(f"{k}={v}" for k, v in params.items())
-
-        return 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(form=multipart_data, files=multipart_data)
-
-
 class LitestarWebSocketAdapter(AsyncWebSocketAdapter):
     def __init__(
         self, view: AsyncBaseHTTPView, request: WebSocket, response: WebSocket

strawberry/quart/views.py

@@ -3,25 +3,24 @@ import warnings
 from collections.abc import AsyncGenerator, Mapping, Sequence
 from datetime import timedelta
 from json.decoder import JSONDecodeError
-from typing import TYPE_CHECKING, Callable, ClassVar, Optional, Union, cast
+from typing import TYPE_CHECKING, Callable, ClassVar, Optional, Union
 from typing_extensions import TypeGuard
 
+from lia import HTTPException, QuartHTTPRequestAdapter
+
 from quart import Request, Response, Websocket, request, websocket
 from quart.ctx import has_websocket_context
 from quart.views import View
 from strawberry.http.async_base_view import (
     AsyncBaseHTTPView,
-    AsyncHTTPRequestAdapter,
     AsyncWebSocketAdapter,
 )
 from strawberry.http.exceptions import (
-    HTTPException,
     NonJsonMessageReceived,
     NonTextMessageReceived,
     WebSocketDisconnected,
 )
 from strawberry.http.ides import GraphQL_IDE
-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
 
@@ -31,35 +30,6 @@ if TYPE_CHECKING:
     from strawberry.schema.base import BaseSchema
 
 
-class QuartHTTPRequestAdapter(AsyncHTTPRequestAdapter):
-    def __init__(self, request: Request) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        return self.request.args.to_dict()
-
-    @property
-    def method(self) -> HTTPMethod:
-        return cast("HTTPMethod", self.request.method.upper())
-
-    @property
-    def content_type(self) -> Optional[str]:
-        return self.request.content_type
-
-    @property
-    def headers(self) -> Mapping[str, str]:
-        return self.request.headers  # type: ignore
-
-    async def get_body(self) -> str:
-        return (await self.request.data).decode()
-
-    async def get_form_data(self) -> FormData:
-        files = await self.request.files
-        form = await self.request.form
-        return FormData(files=files, form=form)
-
-
 class QuartWebSocketAdapter(AsyncWebSocketAdapter):
     def __init__(
         self, view: AsyncBaseHTTPView, request: Websocket, response: Response

strawberry/sanic/views.py

@@ -8,68 +8,29 @@ from typing import (
     Callable,
     Optional,
     Union,
-    cast,
 )
 from typing_extensions import TypeGuard
 
+from lia import HTTPException, SanicHTTPRequestAdapter
+
 from sanic.request import Request
 from sanic.response import HTTPResponse, html
 from sanic.views import HTTPMethodView
-from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncHTTPRequestAdapter
-from strawberry.http.exceptions import HTTPException
+from strawberry.http.async_base_view import AsyncBaseHTTPView
 from strawberry.http.temporal_response import TemporalResponse
-from strawberry.http.types import FormData, HTTPMethod, QueryParams
 from strawberry.http.typevars import (
     Context,
     RootValue,
 )
-from strawberry.sanic.utils import convert_request_to_files_dict
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncGenerator, Mapping
+    from collections.abc import AsyncGenerator
 
     from strawberry.http import GraphQLHTTPResponse
     from strawberry.http.ides import GraphQL_IDE
     from strawberry.schema import BaseSchema
 
 
-class SanicHTTPRequestAdapter(AsyncHTTPRequestAdapter):
-    def __init__(self, request: Request) -> None:
-        self.request = request
-
-    @property
-    def query_params(self) -> QueryParams:
-        # Just a heads up, Sanic's request.args uses urllib.parse.parse_qs
-        # to parse query string parameters. This returns a dictionary where
-        # the keys are the unique variable names and the values are lists
-        # of values for each variable name. To ensure consistency, we're
-        # enforcing the use of the first value in each list.
-        args = self.request.get_args(keep_blank_values=True)
-        return {k: args.get(k, None) for k in args}
-
-    @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
-
-    async def get_body(self) -> str:
-        return self.request.body.decode()
-
-    async def get_form_data(self) -> FormData:
-        assert self.request.form is not None
-
-        files = convert_request_to_files_dict(self.request)
-
-        return FormData(form=self.request.form, files=files)
-
-
 class GraphQLView(
     AsyncBaseHTTPView[
         Request,

strawberry/schema/schema.py

@@ -50,6 +50,7 @@ from strawberry.extensions.directives import (
 from strawberry.extensions.runner import SchemaExtensionsRunner
 from strawberry.printer import print_schema
 from strawberry.schema.schema_converter import GraphQLCoreConverter
+from strawberry.schema.validation_rules.maybe_null import MaybeNullValidationRule
 from strawberry.schema.validation_rules.one_of import OneOfInputValidationRule
 from strawberry.types.base import (
     StrawberryObjectDefinition,
@@ -124,6 +125,7 @@ def validate_document(
 ) -> list[GraphQLError]:
     validation_rules = (
         *validation_rules,
+        MaybeNullValidationRule,
         OneOfInputValidationRule,
     )
     return validate(

strawberry/schema/schema_converter.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import contextlib
 import dataclasses
 import sys
 from functools import partial, reduce
@@ -732,27 +731,14 @@ class GraphQLCoreConverter:
             ) -> Any:
                 # parse field arguments into Strawberry input types and convert
                 # field names to Python equivalents
-                try:
-                    field_args, field_kwargs = get_arguments(
-                        field=field,
-                        source=_source,
-                        info=info,
-                        kwargs=kwargs,
-                        config=self.config,
-                        scalar_registry=self.scalar_registry,
-                    )
-                except Exception as exc:
-                    # Try to import Pydantic ValidationError
-                    with contextlib.suppress(ImportError):
-                        from pydantic import ValidationError
-
-                        if isinstance(
-                            exc, ValidationError
-                        ) and self._should_convert_validation_error(field):
-                            from strawberry.pydantic import Error
-
-                            return Error.from_validation_error(exc)
-                    raise
+                field_args, field_kwargs = get_arguments(
+                    field=field,
+                    source=_source,
+                    info=info,
+                    kwargs=kwargs,
+                    config=self.config,
+                    scalar_registry=self.scalar_registry,
+                )
 
                 resolver_requested_info = False
                 if "info" in field_kwargs:
@@ -813,22 +799,6 @@ class GraphQLCoreConverter:
         _resolver._is_default = not field.base_resolver  # type: ignore
         return _resolver
 
-    def _should_convert_validation_error(self, field: StrawberryField) -> bool:
-        """Check if field return type is a Union containing strawberry.pydantic.Error."""
-        from strawberry.types.union import StrawberryUnion
-
-        field_type = field.type
-        if isinstance(field_type, StrawberryUnion):
-            # Import Error dynamically to avoid circular imports
-            try:
-                from strawberry.pydantic import Error
-
-                return any(union_type is Error for union_type in field_type.types)
-            except ImportError:
-                # If strawberry.pydantic doesn't exist or Error isn't available
-                return False
-        return False
-
     def from_scalar(self, scalar: type) -> GraphQLScalarType:
         from strawberry.relay.types import GlobalID
 
@@ -884,6 +854,13 @@ class GraphQLCoreConverter:
         NoneType = type(None)
         if type_ is None or type_ is NoneType:
             return self.from_type(type_)
+        if isinstance(type_, StrawberryMaybe):
+            # StrawberryMaybe should always generate optional types
+            # because Maybe[T] = Union[Some[T], None] (field can be absent)
+            # But we need to handle the case where of_type is itself optional
+            if isinstance(type_.of_type, StrawberryOptional):
+                return self.from_type(type_.of_type.of_type)
+            return self.from_type(type_.of_type)
         if isinstance(type_, StrawberryOptional):
             return self.from_type(type_.of_type)
         return GraphQLNonNull(self.from_type(type_))