strawberry-graphql 0.275.7__py3-none-any.whl → 0.284.3__py3-none-any.whl

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/dataloader.py

@@ -8,11 +8,8 @@ from dataclasses import dataclass
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     Generic,
-    Optional,
     TypeVar,
-    Union,
     overload,
 )
 
@@ -20,7 +17,14 @@ from .exceptions import WrongNumberOfResultsReturned
 
 if TYPE_CHECKING:
     from asyncio.events import AbstractEventLoop
-    from collections.abc import Awaitable, Hashable, Iterable, Mapping, Sequence
+    from collections.abc import (
+        Awaitable,
+        Callable,
+        Hashable,
+        Iterable,
+        Mapping,
+        Sequence,
+    )
 
 
 T = TypeVar("T")
@@ -46,9 +50,9 @@ class Batch(Generic[K, T]):
         return len(self.tasks)
 
 
-class AbstractCache(Generic[K, T], ABC):
+class AbstractCache(ABC, Generic[K, T]):
     @abstractmethod
-    def get(self, key: K) -> Union[Future[T], None]:
+    def get(self, key: K) -> Future[T] | None:
         pass
 
     @abstractmethod
@@ -65,13 +69,13 @@ class AbstractCache(Generic[K, T], ABC):
 
 
 class DefaultCache(AbstractCache[K, T]):
-    def __init__(self, cache_key_fn: Optional[Callable[[K], Hashable]] = None) -> None:
+    def __init__(self, cache_key_fn: Callable[[K], Hashable] | None = None) -> None:
         self.cache_key_fn: Callable[[K], Hashable] = (
             cache_key_fn if cache_key_fn is not None else lambda x: x
         )
         self.cache_map: dict[Hashable, Future[T]] = {}
 
-    def get(self, key: K) -> Union[Future[T], None]:
+    def get(self, key: K) -> Future[T] | None:
         return self.cache_map.get(self.cache_key_fn(key))
 
     def set(self, key: K, value: Future[T]) -> None:
@@ -85,7 +89,7 @@ class DefaultCache(AbstractCache[K, T]):
 
 
 class DataLoader(Generic[K, T]):
-    batch: Optional[Batch[K, T]] = None
+    batch: Batch[K, T] | None = None
     cache: bool = False
     cache_map: AbstractCache[K, T]
 
@@ -93,12 +97,12 @@ class DataLoader(Generic[K, T]):
     def __init__(
         self,
         # any BaseException is rethrown in 'load', so should be excluded from the T type
-        load_fn: Callable[[list[K]], Awaitable[Sequence[Union[T, BaseException]]]],
-        max_batch_size: Optional[int] = None,
+        load_fn: Callable[[list[K]], Awaitable[Sequence[T | BaseException]]],
+        max_batch_size: int | None = None,
         cache: bool = True,
-        loop: Optional[AbstractEventLoop] = None,
-        cache_map: Optional[AbstractCache[K, T]] = None,
-        cache_key_fn: Optional[Callable[[K], Hashable]] = None,
+        loop: AbstractEventLoop | None = None,
+        cache_map: AbstractCache[K, T] | None = None,
+        cache_key_fn: Callable[[K], Hashable] | None = None,
     ) -> None: ...
 
     # fallback if load_fn is untyped and there's no other info for inference
@@ -106,21 +110,21 @@ class DataLoader(Generic[K, T]):
     def __init__(
         self: DataLoader[K, Any],
         load_fn: Callable[[list[K]], Awaitable[list[Any]]],
-        max_batch_size: Optional[int] = None,
+        max_batch_size: int | None = None,
         cache: bool = True,
-        loop: Optional[AbstractEventLoop] = None,
-        cache_map: Optional[AbstractCache[K, T]] = None,
-        cache_key_fn: Optional[Callable[[K], Hashable]] = None,
+        loop: AbstractEventLoop | None = None,
+        cache_map: AbstractCache[K, T] | None = None,
+        cache_key_fn: Callable[[K], Hashable] | None = None,
     ) -> None: ...
 
     def __init__(
         self,
-        load_fn: Callable[[list[K]], Awaitable[Sequence[Union[T, BaseException]]]],
-        max_batch_size: Optional[int] = None,
+        load_fn: Callable[[list[K]], Awaitable[Sequence[T | BaseException]]],
+        max_batch_size: int | None = None,
         cache: bool = True,
-        loop: Optional[AbstractEventLoop] = None,
-        cache_map: Optional[AbstractCache[K, T]] = None,
-        cache_key_fn: Optional[Callable[[K], Hashable]] = None,
+        loop: AbstractEventLoop | None = None,
+        cache_map: AbstractCache[K, T] | None = None,
+        cache_key_fn: Callable[[K], Hashable] | None = None,
     ):
         self.load_fn = load_fn
         self.max_batch_size = max_batch_size
@@ -244,7 +248,7 @@ async def dispatch_batch(loader: DataLoader, batch: Batch) -> None:
                 expected=len(batch), received=len(values)
             )
 
-        for task, value in zip(batch.tasks, values):
+        for task, value in zip(batch.tasks, values, strict=True):
             # Trying to set_result in a cancelled future would raise
             # asyncio.exceptions.InvalidStateError
             if task.future.cancelled():

strawberry/directive.py

@@ -6,9 +6,7 @@ from typing import (
     TYPE_CHECKING,
     Annotated,
     Any,
-    Callable,
     Generic,
-    Optional,
     TypeVar,
 )
 
@@ -24,6 +22,7 @@ from strawberry.types.unset import UNSET
 
 if TYPE_CHECKING:
     import inspect
+    from collections.abc import Callable
 
     from strawberry.types.arguments import StrawberryArgument
 
@@ -82,17 +81,17 @@ class StrawberryDirectiveResolver(StrawberryResolver[T]):
     )
 
     @cached_property
-    def value_parameter(self) -> Optional[inspect.Parameter]:
+    def value_parameter(self) -> inspect.Parameter | None:
         return self.reserved_parameters.get(VALUE_PARAMSPEC)
 
 
 @dataclasses.dataclass
 class StrawberryDirective(Generic[T]):
     python_name: str
-    graphql_name: Optional[str]
+    graphql_name: str | None
     resolver: StrawberryDirectiveResolver[T]
     locations: list[DirectiveLocation]
-    description: Optional[str] = None
+    description: str | None = None
 
     @cached_property
     def arguments(self) -> list[StrawberryArgument]:
@@ -102,8 +101,8 @@ class StrawberryDirective(Generic[T]):
 def directive(
     *,
     locations: list[DirectiveLocation],
-    description: Optional[str] = None,
-    name: Optional[str] = None,
+    description: str | None = None,
+    name: str | None = None,
 ) -> Callable[[Callable[..., T]], StrawberryDirective[T]]:
     """Decorator to create a GraphQL operation directive.
 

strawberry/django/test/client.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 from strawberry.test import BaseGraphQLTestClient
 
@@ -7,8 +7,8 @@ class GraphQLTestClient(BaseGraphQLTestClient):
     def request(
         self,
         body: dict[str, object],
-        headers: Optional[dict[str, object]] = None,
-        files: Optional[dict[str, object]] = None,
+        headers: dict[str, object] | None = None,
+        files: dict[str, object] | None = None,
     ) -> Any:
         if files:
             return self._client.post(

strawberry/django/views.py

@@ -5,12 +5,8 @@ import warnings
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Optional,
-    Union,
-    cast,
+    TypeGuard,
 )
-from typing_extensions import TypeGuard
 
 from asgiref.sync import markcoroutinefunction
 from django.core.serializers.json import DjangoJSONEncoder
@@ -26,11 +22,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 +34,7 @@ from strawberry.http.typevars import (
 from .context import StrawberryDjangoContext
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncIterator, Mapping
+    from collections.abc import AsyncIterator, Callable
 
     from django.template.response import TemplateResponse
 
@@ -50,7 +45,7 @@ if TYPE_CHECKING:
 
 # TODO: remove this and unify temporal responses
 class TemporalHttpResponse(JsonResponse):
-    status_code: Optional[int] = None  # pyright: ignore
+    status_code: int | None = None  # pyright: ignore
 
     def __init__(self) -> None:
         super().__init__({})
@@ -67,81 +62,14 @@ 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
 
     def __init__(
         self,
         schema: BaseSchema,
-        graphiql: Optional[str] = None,
-        graphql_ide: Optional[GraphQL_IDE] = "graphiql",
+        graphiql: str | None = None,
+        graphql_ide: GraphQL_IDE | None = "graphiql",
         allow_queries_via_get: bool = True,
         multipart_uploads_enabled: bool = False,
         **kwargs: Any,
@@ -163,7 +91,9 @@ class BaseView:
         super().__init__(**kwargs)
 
     def create_response(
-        self, response_data: GraphQLHTTPResponse, sub_response: HttpResponse
+        self,
+        response_data: GraphQLHTTPResponse | list[GraphQLHTTPResponse],
+        sub_response: HttpResponse,
     ) -> HttpResponseBase:
         data = self.encode_json(response_data)
 
@@ -210,13 +140,13 @@ class GraphQLView(
     ],
     View,
 ):
-    graphiql: Optional[bool] = None
-    graphql_ide: Optional[GraphQL_IDE] = "graphiql"
+    graphiql: bool | None = None
+    graphql_ide: GraphQL_IDE | None = "graphiql"
     allow_queries_via_get = True
     schema: BaseSchema = None  # type: ignore
     request_adapter_class = DjangoHTTPRequestAdapter
 
-    def get_root_value(self, request: HttpRequest) -> Optional[RootValue]:
+    def get_root_value(self, request: HttpRequest) -> RootValue | None:
         return None
 
     def get_context(self, request: HttpRequest, response: HttpResponse) -> Context:
@@ -227,7 +157,7 @@ class GraphQLView(
 
     def dispatch(
         self, request: HttpRequest, *args: Any, **kwargs: Any
-    ) -> Union[HttpResponseNotAllowed, TemplateResponse, HttpResponseBase]:
+    ) -> HttpResponseNotAllowed | TemplateResponse | HttpResponseBase:
         try:
             return self.run(request=request)
         except HTTPException as e:
@@ -258,8 +188,8 @@ class AsyncGraphQLView(
     ],
     View,
 ):
-    graphiql: Optional[bool] = None
-    graphql_ide: Optional[GraphQL_IDE] = "graphiql"
+    graphiql: bool | None = None
+    graphql_ide: GraphQL_IDE | None = "graphiql"
     allow_queries_via_get = True
     schema: BaseSchema = None  # type: ignore
     request_adapter_class = AsyncDjangoHTTPRequestAdapter
@@ -274,7 +204,7 @@ class AsyncGraphQLView(
 
         return view
 
-    async def get_root_value(self, request: HttpRequest) -> Optional[RootValue]:
+    async def get_root_value(self, request: HttpRequest) -> RootValue | None:
         return None
 
     async def get_context(
@@ -287,7 +217,7 @@ class AsyncGraphQLView(
 
     async def dispatch(  # pyright: ignore
         self, request: HttpRequest, *args: Any, **kwargs: Any
-    ) -> Union[HttpResponseNotAllowed, TemplateResponse, HttpResponseBase]:
+    ) -> HttpResponseNotAllowed | TemplateResponse | HttpResponseBase:
         try:
             return await self.run(request=request)
         except HTTPException as e:
@@ -307,11 +237,11 @@ class AsyncGraphQLView(
     def is_websocket_request(self, request: HttpRequest) -> TypeGuard[HttpRequest]:
         return False
 
-    async def pick_websocket_subprotocol(self, request: HttpRequest) -> Optional[str]:
+    async def pick_websocket_subprotocol(self, request: HttpRequest) -> str | None:
         raise NotImplementedError
 
     async def create_websocket_response(
-        self, request: HttpRequest, subprotocol: Optional[str]
+        self, request: HttpRequest, subprotocol: str | None
     ) -> TemporalHttpResponse:
         raise NotImplementedError
 

strawberry/exceptions/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from functools import cached_property
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING
 
 from graphql import GraphQLError
 
@@ -72,20 +72,20 @@ class InvalidTypeInputForUnion(Exception):
 class MissingTypesForGenericError(Exception):
     """Raised when a generic types was used without passing any type."""
 
-    def __init__(self, annotation: Union[StrawberryType, type]) -> None:
+    def __init__(self, annotation: StrawberryType | type) -> None:
         message = f'The type "{annotation!r}" is generic, but no type has been passed'
 
         super().__init__(message)
 
 
 class UnsupportedTypeError(StrawberryException):
-    def __init__(self, annotation: Union[StrawberryType, type]) -> None:
+    def __init__(self, annotation: StrawberryType | type) -> None:
         message = f"{annotation} conversion is not supported"
 
         super().__init__(message)
 
     @cached_property
-    def exception_source(self) -> Optional[ExceptionSource]:
+    def exception_source(self) -> ExceptionSource | None:
         return None
 
 

strawberry/exceptions/conflicting_arguments.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from functools import cached_property
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from .exception import StrawberryException
 from .utils.source_finder import SourceFinder
@@ -43,7 +43,7 @@ class ConflictingArgumentsError(StrawberryException):
         )
 
     @cached_property
-    def exception_source(self) -> Optional[ExceptionSource]:
+    def exception_source(self) -> ExceptionSource | None:
         if self.function is None:
             return None  # pragma: no cover
 

strawberry/exceptions/duplicated_type_name.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from functools import cached_property
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from .exception import StrawberryException
 from .utils.source_finder import SourceFinder
@@ -17,8 +17,8 @@ class DuplicatedTypeName(StrawberryException):
 
     def __init__(
         self,
-        first_cls: Optional[type],
-        second_cls: Optional[type],
+        first_cls: type | None,
+        second_cls: type | None,
         duplicated_type_name: str,
     ) -> None:
         self.first_cls = first_cls
@@ -66,7 +66,7 @@ class DuplicatedTypeName(StrawberryException):
         )
 
     @cached_property
-    def exception_source(self) -> Optional[ExceptionSource]:
+    def exception_source(self) -> ExceptionSource | None:
         if self.first_cls is None:
             return None  # pragma: no cover
 

strawberry/exceptions/exception.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from functools import cached_property
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from strawberry.utils.str_converters import to_kebab_case
 
@@ -40,7 +40,7 @@ class StrawberryException(Exception, ABC):
 
     @cached_property
     @abstractmethod
-    def exception_source(self) -> Optional[ExceptionSource]:
+    def exception_source(self) -> ExceptionSource | None:
         return None
 
     @property
@@ -61,7 +61,7 @@ class StrawberryException(Exception, ABC):
             f"[link={self.documentation_url}]{self.documentation_url}"
         ).strip()
 
-    def __rich__(self) -> Optional[RenderableType]:
+    def __rich__(self) -> RenderableType | None:
         from rich.box import SIMPLE
         from rich.console import Group
         from rich.panel import Panel

strawberry/exceptions/handler.py

@@ -1,8 +1,9 @@
 import os
 import sys
 import threading
+from collections.abc import Callable
 from types import TracebackType
-from typing import Any, Callable, Optional, cast
+from typing import Any, cast
 
 from .exception import StrawberryException, UnableToFindExceptionSource
 
@@ -10,7 +11,7 @@ original_threading_exception_hook = threading.excepthook
 
 
 ExceptionHandler = Callable[
-    [type[BaseException], BaseException, Optional[TracebackType]], None
+    [type[BaseException], BaseException, TracebackType | None], None
 ]
 
 
@@ -31,7 +32,7 @@ def _get_handler(exception_type: type[BaseException]) -> ExceptionHandler:
             def _handler(
                 exception_type: type[BaseException],
                 exception: BaseException,
-                traceback: Optional[TracebackType],
+                traceback: TracebackType | None,
             ) -> None:
                 try:
                     rich.print(exception)
@@ -49,7 +50,7 @@ def _get_handler(exception_type: type[BaseException]) -> ExceptionHandler:
 def strawberry_exception_handler(
     exception_type: type[BaseException],
     exception: BaseException,
-    traceback: Optional[TracebackType],
+    traceback: TracebackType | None,
 ) -> None:
     _get_handler(exception_type)(exception_type, exception, traceback)
 
@@ -57,9 +58,9 @@ def strawberry_exception_handler(
 def strawberry_threading_exception_handler(
     args: tuple[
         type[BaseException],
-        Optional[BaseException],
-        Optional[TracebackType],
-        Optional[threading.Thread],
+        BaseException | None,
+        TracebackType | None,
+        threading.Thread | None,
     ],
 ) -> None:
     (exception_type, exception, traceback, _) = args