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

strawberry/subscriptions/protocols/graphql_transport_ws/types.py

@@ -1,5 +1,5 @@
-from typing import TypedDict, Union
-from typing_extensions import Literal, NotRequired
+from typing import Literal, TypeAlias, TypedDict
+from typing_extensions import NotRequired
 
 from graphql import GraphQLFormattedError
 
@@ -8,35 +8,35 @@ class ConnectionInitMessage(TypedDict):
     """Direction: Client -> Server."""
 
     type: Literal["connection_init"]
-    payload: NotRequired[Union[dict[str, object], None]]
+    payload: NotRequired[dict[str, object] | None]
 
 
 class ConnectionAckMessage(TypedDict):
     """Direction: Server -> Client."""
 
     type: Literal["connection_ack"]
-    payload: NotRequired[Union[dict[str, object], None]]
+    payload: NotRequired[dict[str, object] | None]
 
 
 class PingMessage(TypedDict):
     """Direction: bidirectional."""
 
     type: Literal["ping"]
-    payload: NotRequired[Union[dict[str, object], None]]
+    payload: NotRequired[dict[str, object] | None]
 
 
 class PongMessage(TypedDict):
     """Direction: bidirectional."""
 
     type: Literal["pong"]
-    payload: NotRequired[Union[dict[str, object], None]]
+    payload: NotRequired[dict[str, object] | None]
 
 
 class SubscribeMessagePayload(TypedDict):
-    operationName: NotRequired[Union[str, None]]
+    operationName: NotRequired[str | None]
     query: str
-    variables: NotRequired[Union[dict[str, object], None]]
-    extensions: NotRequired[Union[dict[str, object], None]]
+    variables: NotRequired[dict[str, object] | None]
+    extensions: NotRequired[dict[str, object] | None]
 
 
 class SubscribeMessage(TypedDict):
@@ -49,7 +49,7 @@ class SubscribeMessage(TypedDict):
 
 class NextMessagePayload(TypedDict):
     errors: NotRequired[list[GraphQLFormattedError]]
-    data: NotRequired[Union[dict[str, object], None]]
+    data: NotRequired[dict[str, object] | None]
     extensions: NotRequired[dict[str, object]]
 
 
@@ -76,16 +76,16 @@ class CompleteMessage(TypedDict):
     type: Literal["complete"]
 
 
-Message = Union[
-    ConnectionInitMessage,
-    ConnectionAckMessage,
-    PingMessage,
-    PongMessage,
-    SubscribeMessage,
-    NextMessage,
-    ErrorMessage,
-    CompleteMessage,
-]
+Message: TypeAlias = (
+    ConnectionInitMessage
+    | ConnectionAckMessage
+    | PingMessage
+    | PongMessage
+    | SubscribeMessage
+    | NextMessage
+    | ErrorMessage
+    | CompleteMessage
+)
 
 
 __all__ = [

strawberry/subscriptions/protocols/graphql_ws/handlers.py

@@ -7,7 +7,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Generic,
-    Optional,
     cast,
 )
 
@@ -27,7 +26,6 @@ from strawberry.subscriptions.protocols.graphql_ws.types import (
 )
 from strawberry.types.execution import ExecutionResult, PreExecutionError
 from strawberry.types.unset import UnsetType
-from strawberry.utils.debug import pretty_print_graphql_operation
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator
@@ -42,21 +40,19 @@ class BaseGraphQLWSHandler(Generic[Context, RootValue]):
         view: AsyncBaseHTTPView[Any, Any, Any, Any, Any, Context, RootValue],
         websocket: AsyncWebSocketAdapter,
         context: Context,
-        root_value: Optional[RootValue],
+        root_value: RootValue | None,
         schema: BaseSchema,
-        debug: bool,
         keep_alive: bool,
-        keep_alive_interval: Optional[float],
+        keep_alive_interval: float | None,
     ) -> None:
         self.view = view
         self.websocket = websocket
         self.context = context
         self.root_value = root_value
         self.schema = schema
-        self.debug = debug
         self.keep_alive = keep_alive
         self.keep_alive_interval = keep_alive_interval
-        self.keep_alive_task: Optional[asyncio.Task] = None
+        self.keep_alive_task: asyncio.Task | None = None
         self.subscriptions: dict[str, AsyncGenerator] = {}
         self.tasks: dict[str, asyncio.Task] = {}
 
@@ -139,9 +135,6 @@ class BaseGraphQLWSHandler(Generic[Context, RootValue]):
         operation_name = payload.get("operationName")
         variables = payload.get("variables")
 
-        if self.debug:
-            pretty_print_graphql_operation(operation_name, query, variables)
-
         result_handler = self.handle_async_results(
             operation_id, query, operation_name, variables
         )
@@ -161,8 +154,8 @@ class BaseGraphQLWSHandler(Generic[Context, RootValue]):
         self,
         operation_id: str,
         query: str,
-        operation_name: Optional[str],
-        variables: Optional[dict[str, object]],
+        operation_name: str | None,
+        variables: dict[str, object] | None,
     ) -> None:
         try:
             result_source = await self.schema.subscribe(

strawberry/subscriptions/protocols/graphql_ws/types.py

@@ -1,5 +1,5 @@
-from typing import TypedDict, Union
-from typing_extensions import Literal, NotRequired
+from typing import Literal, TypeAlias, TypedDict
+from typing_extensions import NotRequired
 
 from graphql import GraphQLFormattedError
 
@@ -69,18 +69,18 @@ class ConnectionKeepAliveMessage(TypedDict):
     type: Literal["ka"]
 
 
-OperationMessage = Union[
-    ConnectionInitMessage,
-    StartMessage,
-    StopMessage,
-    ConnectionTerminateMessage,
-    ConnectionErrorMessage,
-    ConnectionAckMessage,
-    DataMessage,
-    ErrorMessage,
-    CompleteMessage,
-    ConnectionKeepAliveMessage,
-]
+OperationMessage: TypeAlias = (
+    ConnectionInitMessage
+    | StartMessage
+    | StopMessage
+    | ConnectionTerminateMessage
+    | ConnectionErrorMessage
+    | ConnectionAckMessage
+    | DataMessage
+    | ErrorMessage
+    | CompleteMessage
+    | ConnectionKeepAliveMessage
+)
 
 
 __all__ = [

strawberry/test/client.py

@@ -4,25 +4,25 @@ import json
 import warnings
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Optional, Union
-from typing_extensions import Literal, TypedDict
+from typing import TYPE_CHECKING, Any, Literal
+from typing_extensions import TypedDict
 
 if TYPE_CHECKING:
-    from collections.abc import Coroutine, Mapping
+    from collections.abc import Coroutine
 
     from graphql import GraphQLFormattedError
 
 
 @dataclass
 class Response:
-    errors: Optional[list[GraphQLFormattedError]]
-    data: Optional[dict[str, object]]
-    extensions: Optional[dict[str, object]]
+    errors: list[GraphQLFormattedError] | None
+    data: dict[str, object] | None
+    extensions: dict[str, object] | None
 
 
 class Body(TypedDict, total=False):
     query: str
-    variables: Optional[dict[str, object]]
+    variables: dict[str, object] | None
 
 
 class BaseGraphQLTestClient(ABC):
@@ -37,12 +37,12 @@ class BaseGraphQLTestClient(ABC):
     def query(
         self,
         query: str,
-        variables: Optional[dict[str, Mapping]] = None,
-        headers: Optional[dict[str, object]] = None,
-        asserts_errors: Optional[bool] = None,
-        files: Optional[dict[str, object]] = None,
-        assert_no_errors: Optional[bool] = True,
-    ) -> Union[Coroutine[Any, Any, Response], Response]:
+        variables: dict[str, Any] | None = None,
+        headers: dict[str, object] | None = None,
+        asserts_errors: bool | None = None,
+        files: dict[str, object] | None = None,
+        assert_no_errors: bool | None = True,
+    ) -> Coroutine[Any, Any, Response] | Response:
         body = self._build_body(query, variables, files)
 
         resp = self.request(body, headers, files)
@@ -74,16 +74,16 @@ class BaseGraphQLTestClient(ABC):
     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:
         raise NotImplementedError
 
     def _build_body(
         self,
         query: str,
-        variables: Optional[dict[str, Mapping]] = None,
-        files: Optional[dict[str, object]] = None,
+        variables: dict[str, Any] | None = None,
+        files: dict[str, object] | None = None,
     ) -> dict[str, object]:
         body: dict[str, object] = {"query": query}
 
@@ -105,7 +105,7 @@ class BaseGraphQLTestClient(ABC):
 
     @staticmethod
     def _build_multipart_file_map(
-        variables: dict[str, Mapping], files: dict[str, object]
+        variables: dict[str, Any], files: dict[str, object]
     ) -> dict[str, list[str]]:
         """Creates the file mapping between the variables and the files objects passed as key arguments.
 

strawberry/tools/create_type.py

@@ -1,6 +1,5 @@
 import types
 from collections.abc import Sequence
-from typing import Optional
 
 import strawberry
 from strawberry.types.field import StrawberryField
@@ -11,8 +10,8 @@ def create_type(
     fields: list[StrawberryField],
     is_input: bool = False,
     is_interface: bool = False,
-    description: Optional[str] = None,
-    directives: Optional[Sequence[object]] = (),
+    description: str | None = None,
+    directives: Sequence[object] | None = (),
     extend: bool = False,
 ) -> type:
     """Create a Strawberry type from a list of StrawberryFields.

strawberry/types/arguments.py

@@ -6,11 +6,10 @@ from typing import (
     TYPE_CHECKING,
     Annotated,
     Any,
-    Optional,
-    Union,
     cast,
+    get_args,
+    get_origin,
 )
-from typing_extensions import get_args, get_origin
 
 from strawberry.annotation import StrawberryAnnotation
 from strawberry.exceptions import MultipleStrawberryArgumentsError, UnsupportedTypeError
@@ -47,19 +46,19 @@ DEPRECATED_NAMES: dict[str, str] = {
 
 
 class StrawberryArgumentAnnotation:
-    description: Optional[str]
-    name: Optional[str]
-    deprecation_reason: Optional[str]
+    description: str | None
+    name: str | None
+    deprecation_reason: str | None
     directives: Iterable[object]
     metadata: Mapping[Any, Any]
 
     def __init__(
         self,
-        description: Optional[str] = None,
-        name: Optional[str] = None,
-        deprecation_reason: Optional[str] = None,
+        description: str | None = None,
+        name: str | None = None,
+        deprecation_reason: str | None = None,
         directives: Iterable[object] = (),
-        metadata: Optional[Mapping[Any, Any]] = None,
+        metadata: Mapping[Any, Any] | None = None,
     ) -> None:
         self.description = description
         self.name = name
@@ -72,14 +71,14 @@ class StrawberryArgument:
     def __init__(
         self,
         python_name: str,
-        graphql_name: Optional[str],
+        graphql_name: str | None,
         type_annotation: StrawberryAnnotation,
         is_subscription: bool = False,
-        description: Optional[str] = None,
+        description: str | None = None,
         default: object = _deprecated_UNSET,
-        deprecation_reason: Optional[str] = None,
+        deprecation_reason: str | None = None,
         directives: Iterable[object] = (),
-        metadata: Optional[Mapping[Any, Any]] = None,
+        metadata: Mapping[Any, Any] | None = None,
     ) -> None:
         self.python_name = python_name
         self.graphql_name = graphql_name
@@ -130,7 +129,7 @@ class StrawberryArgument:
                         )
 
     @property
-    def type(self) -> Union[StrawberryType, type]:
+    def type(self) -> StrawberryType | type:
         return self.type_annotation.resolve()
 
     @property
@@ -145,8 +144,8 @@ class StrawberryArgument:
 
 
 def _is_leaf_type(
-    type_: Union[StrawberryType, type],
-    scalar_registry: Mapping[object, Union[ScalarWrapper, ScalarDefinition]],
+    type_: StrawberryType | type,
+    scalar_registry: Mapping[object, ScalarWrapper | ScalarDefinition],
     skip_classes: tuple[type, ...] = (),
 ) -> bool:
     if type_ in skip_classes:
@@ -169,8 +168,8 @@ def _is_leaf_type(
 
 
 def _is_optional_leaf_type(
-    type_: Union[StrawberryType, type],
-    scalar_registry: Mapping[object, Union[ScalarWrapper, ScalarDefinition]],
+    type_: StrawberryType | type,
+    scalar_registry: Mapping[object, ScalarWrapper | ScalarDefinition],
     skip_classes: tuple[type, ...] = (),
 ) -> bool:
     if type_ in skip_classes:
@@ -184,17 +183,31 @@ def _is_optional_leaf_type(
 
 def convert_argument(
     value: object,
-    type_: Union[StrawberryType, type],
-    scalar_registry: Mapping[object, Union[ScalarWrapper, ScalarDefinition]],
+    type_: StrawberryType | type,
+    scalar_registry: Mapping[object, ScalarWrapper | ScalarDefinition],
     config: StrawberryConfig,
 ) -> object:
     from strawberry.relay.types import GlobalID
 
     # TODO: move this somewhere else and make it first class
-    if isinstance(type_, StrawberryOptional):
+    # Handle StrawberryMaybe first, since it extends StrawberryOptional
+    if isinstance(type_, StrawberryMaybe):
+        # Check if this is Maybe[T | None] (has StrawberryOptional as of_type)
+        if isinstance(type_.of_type, StrawberryOptional):
+            # This is Maybe[T | None] - allows null values
+            res = convert_argument(value, type_.of_type, scalar_registry, config)
+
+            return Some(res)
+
+        # This is Maybe[T] - validation for null values is handled by MaybeNullValidationRule
+        # Convert the value and wrap in Some()
         res = convert_argument(value, type_.of_type, scalar_registry, config)
 
-        return Some(res) if isinstance(type_, StrawberryMaybe) else res
+        return Some(res)
+
+    # Handle regular StrawberryOptional (not Maybe)
+    if isinstance(type_, StrawberryOptional):
+        return convert_argument(value, type_.of_type, scalar_registry, config)
 
     if value is None:
         return None
@@ -257,7 +270,7 @@ def convert_argument(
 def convert_arguments(
     value: dict[str, Any],
     arguments: list[StrawberryArgument],
-    scalar_registry: Mapping[object, Union[ScalarWrapper, ScalarDefinition]],
+    scalar_registry: Mapping[object, ScalarWrapper | ScalarDefinition],
     config: StrawberryConfig,
 ) -> dict[str, Any]:
     """Converts a nested dictionary to a dictionary of actual types.
@@ -289,11 +302,11 @@ def convert_arguments(
 
 
 def argument(
-    description: Optional[str] = None,
-    name: Optional[str] = None,
-    deprecation_reason: Optional[str] = None,
+    description: str | None = None,
+    name: str | None = None,
+    deprecation_reason: str | None = None,
     directives: Iterable[object] = (),
-    metadata: Optional[Mapping[Any, Any]] = None,
+    metadata: Mapping[Any, Any] | None = None,
 ) -> StrawberryArgumentAnnotation:
     """Function to add metadata to an argument, like a description or deprecation reason.
 

strawberry/types/auto.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
-from typing import Annotated, Any, Optional, Union, cast
-from typing_extensions import get_args, get_origin
+from typing import Annotated, Any, cast, get_args, get_origin
 
 from strawberry.annotation import StrawberryAnnotation
 from strawberry.types.base import StrawberryType
@@ -24,7 +23,7 @@ class StrawberryAutoMeta(type):
     """
 
     def __init__(cls, *args: str, **kwargs: Any) -> None:
-        cls._instance: Optional[StrawberryAuto] = None
+        cls._instance: StrawberryAuto | None = None
         super().__init__(*args, **kwargs)
 
     def __call__(cls, *args: str, **kwargs: Any) -> Any:
@@ -35,7 +34,7 @@ class StrawberryAutoMeta(type):
 
     def __instancecheck__(
         cls,
-        instance: Union[StrawberryAuto, StrawberryAnnotation, StrawberryType, type],
+        instance: StrawberryAuto | StrawberryAnnotation | StrawberryType | type,
     ) -> bool:
         if isinstance(instance, StrawberryAnnotation):
             resolved = instance.raw_annotation

strawberry/types/base.py

@@ -5,14 +5,12 @@ from abc import ABC, abstractmethod
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     ClassVar,
-    Optional,
+    Literal,
     TypeVar,
-    Union,
     overload,
 )
-from typing_extensions import Literal, Protocol, Self, deprecated
+from typing_extensions import Protocol, Self, deprecated
 
 from strawberry.utils.deprecations import DEPRECATION_MESSAGES, DeprecatedDescriptor
 from strawberry.utils.inspect import get_specialized_type_var_map
@@ -20,8 +18,8 @@ from strawberry.utils.typing import is_concrete_generic
 from strawberry.utils.typing import is_generic as is_type_generic
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping, Sequence
-    from typing_extensions import TypeGuard
+    from collections.abc import Callable, Mapping, Sequence
+    from typing import TypeGuard
 
     from graphql import GraphQLAbstractType, GraphQLResolveInfo
 
@@ -51,9 +49,9 @@ class StrawberryType(ABC):
     def copy_with(
         self,
         type_var_map: Mapping[
-            str, Union[StrawberryType, type[WithStrawberryObjectDefinition]]
+            str, StrawberryType | type[WithStrawberryObjectDefinition]
         ],
-    ) -> Union[StrawberryType, type[WithStrawberryObjectDefinition]]:
+    ) -> StrawberryType | type[WithStrawberryObjectDefinition]:
         raise NotImplementedError
 
     @property
@@ -87,7 +85,7 @@ class StrawberryType(ABC):
 
 class StrawberryContainer(StrawberryType):
     def __init__(
-        self, of_type: Union[StrawberryType, type[WithStrawberryObjectDefinition], type]
+        self, of_type: StrawberryType | type[WithStrawberryObjectDefinition] | type
     ) -> None:
         self.of_type = of_type
 
@@ -117,7 +115,7 @@ class StrawberryContainer(StrawberryType):
     def copy_with(
         self,
         type_var_map: Mapping[
-            str, Union[StrawberryType, type[WithStrawberryObjectDefinition]]
+            str, StrawberryType | type[WithStrawberryObjectDefinition]
         ],
     ) -> Self:
         of_type_copy = self.of_type
@@ -155,7 +153,7 @@ class StrawberryList(StrawberryContainer): ...
 class StrawberryOptional(StrawberryContainer):
     def __init__(
         self,
-        of_type: Union[StrawberryType, type[WithStrawberryObjectDefinition], type],
+        of_type: StrawberryType | type[WithStrawberryObjectDefinition] | type,
     ) -> None:
         super().__init__(of_type)
 
@@ -169,8 +167,8 @@ class StrawberryTypeVar(StrawberryType):
         self.type_var = type_var
 
     def copy_with(
-        self, type_var_map: Mapping[str, Union[StrawberryType, type]]
-    ) -> Union[StrawberryType, type]:
+        self, type_var_map: Mapping[str, StrawberryType | type]
+    ) -> StrawberryType | type:
         return type_var_map[self.type_var.__name__]
 
     @property
@@ -229,14 +227,14 @@ def get_object_definition(
     obj: Any,
     *,
     strict: bool = False,
-) -> Optional[StrawberryObjectDefinition]: ...
+) -> StrawberryObjectDefinition | None: ...
 
 
 def get_object_definition(
     obj: Any,
     *,
     strict: bool = False,
-) -> Optional[StrawberryObjectDefinition]:
+) -> StrawberryObjectDefinition | None:
     definition = obj.__strawberry_definition__ if has_object_definition(obj) else None
     if strict and definition is None:
         raise TypeError(f"{obj!r} does not have a StrawberryObjectDefinition")
@@ -256,20 +254,18 @@ class StrawberryObjectDefinition(StrawberryType):
     is_input: bool
     is_interface: bool
     origin: type[Any]
-    description: Optional[str]
+    description: str | None
     interfaces: list[StrawberryObjectDefinition]
     extend: bool
-    directives: Optional[Sequence[object]]
-    is_type_of: Optional[Callable[[Any, GraphQLResolveInfo], bool]]
-    resolve_type: Optional[
-        Callable[[Any, GraphQLResolveInfo, GraphQLAbstractType], str]
-    ]
+    directives: Sequence[object] | None
+    is_type_of: Callable[[Any, GraphQLResolveInfo], bool] | None
+    resolve_type: Callable[[Any, GraphQLResolveInfo, GraphQLAbstractType], str] | None
 
     fields: list[StrawberryField]
 
-    concrete_of: Optional[StrawberryObjectDefinition] = None
+    concrete_of: StrawberryObjectDefinition | None = None
     """Concrete implementations of Generic TypeDefinitions fill this in"""
-    type_var_map: Mapping[str, Union[StrawberryType, type]] = dataclasses.field(
+    type_var_map: Mapping[str, StrawberryType | type] = dataclasses.field(
         default_factory=dict
     )
 
@@ -291,12 +287,14 @@ class StrawberryObjectDefinition(StrawberryType):
             resolved_type = StrawberryAnnotation(passed_type).resolve()
             resolved_types.append(resolved_type)
 
-        type_var_map = dict(zip((param.__name__ for param in params), resolved_types))
+        type_var_map = dict(
+            zip((param.__name__ for param in params), resolved_types, strict=True)
+        )
 
         return self.copy_with(type_var_map)
 
     def copy_with(
-        self, type_var_map: Mapping[str, Union[StrawberryType, type]]
+        self, type_var_map: Mapping[str, StrawberryType | type]
     ) -> type[WithStrawberryObjectDefinition]:
         fields = [field.copy_with(type_var_map) for field in self.fields]
 
@@ -332,7 +330,7 @@ class StrawberryObjectDefinition(StrawberryType):
 
         return new_type
 
-    def get_field(self, python_name: str) -> Optional[StrawberryField]:
+    def get_field(self, python_name: str) -> StrawberryField | None:
         return next(
             (field for field in self.fields if field.python_name == python_name), None
         )
@@ -354,7 +352,7 @@ class StrawberryObjectDefinition(StrawberryType):
         )
 
     @property
-    def specialized_type_var_map(self) -> Optional[dict[str, type]]:
+    def specialized_type_var_map(self) -> dict[str, type] | None:
         return get_specialized_type_var_map(self.origin)
 
     @property