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

strawberry/schema/schema_converter.py

@@ -2,15 +2,14 @@ from __future__ import annotations
 
 import dataclasses
 import sys
+import typing
 from functools import partial, reduce
 from typing import (
     TYPE_CHECKING,
+    Annotated,
     Any,
-    Callable,
     Generic,
-    Optional,
     TypeVar,
-    Union,
     cast,
 )
 from typing_extensions import Protocol
@@ -80,7 +79,7 @@ from . import compat
 from .types.concrete_type import ConcreteType
 
 if TYPE_CHECKING:
-    from collections.abc import Awaitable, Mapping
+    from collections.abc import Awaitable, Callable, Mapping
 
     from graphql import (
         GraphQLInputType,
@@ -100,17 +99,17 @@ if TYPE_CHECKING:
 
 FieldType = TypeVar(
     "FieldType",
-    bound=Union[GraphQLField, GraphQLInputField],
+    bound=GraphQLField | GraphQLInputField,
     covariant=True,
 )
 
 
-class FieldConverterProtocol(Generic[FieldType], Protocol):
+class FieldConverterProtocol(Protocol, Generic[FieldType]):
     def __call__(  # pragma: no cover
         self,
         field: StrawberryField,
         *,
-        type_definition: Optional[StrawberryObjectDefinition] = None,
+        type_definition: StrawberryObjectDefinition | None = None,
     ) -> FieldType: ...
 
 
@@ -180,7 +179,7 @@ class CustomGraphQLEnumType(GraphQLEnumType):
         return self.wrapped_cls(super().parse_value(input_value))
 
     def parse_literal(
-        self, value_node: ValueNode, _variables: Optional[dict[str, Any]] = None
+        self, value_node: ValueNode, _variables: dict[str, Any] | None = None
     ) -> Any:
         return self.wrapped_cls(super().parse_literal(value_node, _variables))
 
@@ -192,7 +191,7 @@ def get_arguments(
     info: Info,
     kwargs: Any,
     config: StrawberryConfig,
-    scalar_registry: Mapping[object, Union[ScalarWrapper, ScalarDefinition]],
+    scalar_registry: Mapping[object, ScalarWrapper | ScalarDefinition],
 ) -> tuple[list[Any], dict[str, Any]]:
     # TODO: An extension might have changed the resolver arguments,
     # but we need them here since we are calling it.
@@ -249,7 +248,7 @@ class GraphQLCoreConverter:
     def __init__(
         self,
         config: StrawberryConfig,
-        scalar_overrides: Mapping[object, Union[ScalarWrapper, ScalarDefinition]],
+        scalar_overrides: Mapping[object, ScalarWrapper | ScalarDefinition],
         get_fields: Callable[[StrawberryObjectDefinition], list[StrawberryField]],
     ) -> None:
         self.type_map: dict[str, ConcreteType] = {}
@@ -259,8 +258,8 @@ class GraphQLCoreConverter:
 
     def _get_scalar_registry(
         self,
-        scalar_overrides: Mapping[object, Union[ScalarWrapper, ScalarDefinition]],
-    ) -> Mapping[object, Union[ScalarWrapper, ScalarDefinition]]:
+        scalar_overrides: Mapping[object, ScalarWrapper | ScalarDefinition],
+    ) -> Mapping[object, ScalarWrapper | ScalarDefinition]:
         scalar_registry = {**DEFAULT_SCALAR_REGISTRY}
 
         global_id_name = "GlobalID" if self.config.relay_use_legacy_global_id else "ID"
@@ -407,7 +406,7 @@ class GraphQLCoreConverter:
         self,
         field: StrawberryField,
         *,
-        type_definition: Optional[StrawberryObjectDefinition] = None,
+        type_definition: StrawberryObjectDefinition | None = None,
     ) -> GraphQLField:
         # self.from_resolver needs to be called before accessing field.type because
         # in there a field extension might want to change the type during its apply
@@ -445,7 +444,7 @@ class GraphQLCoreConverter:
         self,
         field: StrawberryField,
         *,
-        type_definition: Optional[StrawberryObjectDefinition] = None,
+        type_definition: StrawberryObjectDefinition | None = None,
     ) -> GraphQLInputField:
         field_type = cast(
             "GraphQLInputType",
@@ -556,14 +555,14 @@ class GraphQLCoreConverter:
 
         def _get_resolve_type() -> Callable[
             [Any, GraphQLResolveInfo, GraphQLAbstractType],
-            Union[Awaitable[Optional[str]], str, None],
+            Awaitable[str | None] | str | None,
         ]:
             if interface.resolve_type:
                 return interface.resolve_type
 
             def resolve_type(
                 obj: Any, info: GraphQLResolveInfo, abstract_type: GraphQLAbstractType
-            ) -> Union[Awaitable[Optional[str]], str, None]:
+            ) -> Awaitable[str | None] | str | None:
                 if isinstance(obj, interface.origin):
                     type_definition = get_object_definition(obj, strict=True)
 
@@ -578,7 +577,7 @@ class GraphQLCoreConverter:
                     # all the types in the schema, but we should probably
                     # optimize this
 
-                    return_type: Optional[GraphQLType] = None
+                    return_type: GraphQLType | None = None
 
                     for possible_concrete_type in self.type_map.values():
                         possible_type = possible_concrete_type.definition
@@ -639,7 +638,7 @@ class GraphQLCoreConverter:
             assert isinstance(graphql_object_type, GraphQLObjectType)  # For mypy
             return graphql_object_type
 
-        def _get_is_type_of() -> Optional[Callable[[Any, GraphQLResolveInfo], bool]]:
+        def _get_is_type_of() -> Callable[[Any, GraphQLResolveInfo], bool] | None:
             if object_type.is_type_of:
                 return object_type.is_type_of
 
@@ -849,19 +848,32 @@ class GraphQLCoreConverter:
         return implementation
 
     def from_maybe_optional(
-        self, type_: Union[StrawberryType, type]
-    ) -> Union[GraphQLNullableType, GraphQLNonNull]:
+        self, type_: StrawberryType | type
+    ) -> GraphQLNullableType | GraphQLNonNull:
         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_))
 
-    def from_type(self, type_: Union[StrawberryType, type]) -> GraphQLNullableType:
+    def from_type(self, type_: StrawberryType | type) -> GraphQLNullableType:
         if compat.is_graphql_generic(type_):
             raise MissingTypesForGenericError(type_)
 
+        # to handle lazy unions
+        if typing.get_origin(type_) is Annotated:
+            args = typing.get_args(type_)
+            if len(args) >= 2 and isinstance(args[1], StrawberryUnion):
+                type_ = args[1]
+
         if isinstance(type_, EnumDefinition):  # TODO: Replace with StrawberryEnum
             return self.from_enum(type_)
         if compat.is_input_type(type_):  # TODO: Replace with StrawberryInputObject
@@ -945,7 +957,7 @@ class GraphQLCoreConverter:
     def _get_is_type_of(
         self,
         object_type: StrawberryObjectDefinition,
-    ) -> Optional[Callable[[Any, GraphQLResolveInfo], bool]]:
+    ) -> Callable[[Any, GraphQLResolveInfo], bool] | None:
         if object_type.is_type_of:
             return object_type.is_type_of
 
@@ -1003,43 +1015,11 @@ class GraphQLCoreConverter:
         first_type_definition = cached_type.definition
         second_type_definition = type_definition
 
-        # TODO: maybe move this on the StrawberryType class
-        if (
-            isinstance(first_type_definition, StrawberryObjectDefinition)
-            and isinstance(second_type_definition, StrawberryObjectDefinition)
-            and first_type_definition.concrete_of is not None
-            and first_type_definition.concrete_of == second_type_definition.concrete_of
-            and (
-                first_type_definition.type_var_map.keys()
-                == second_type_definition.type_var_map.keys()
-            )
+        if self.is_same_type_definition(
+            first_type_definition,
+            second_type_definition,
         ):
-            # manually compare type_var_maps while resolving any lazy types
-            # so that they're considered equal to the actual types they're referencing
-            equal = True
-            for type_var, type1 in first_type_definition.type_var_map.items():
-                type2 = second_type_definition.type_var_map[type_var]
-                # both lazy types are always resolved because two different lazy types
-                # may be referencing the same actual type
-                if isinstance(type1, LazyType):
-                    type1 = type1.resolve_type()  # noqa: PLW2901
-                elif isinstance(type1, StrawberryOptional) and isinstance(
-                    type1.of_type, LazyType
-                ):
-                    type1.of_type = type1.of_type.resolve_type()
-
-                if isinstance(type2, LazyType):
-                    type2 = type2.resolve_type()
-                elif isinstance(type2, StrawberryOptional) and isinstance(
-                    type2.of_type, LazyType
-                ):
-                    type2.of_type = type2.of_type.resolve_type()
-
-                if type1 != type2:
-                    equal = False
-                    break
-            if equal:
-                return
+            return
 
         if isinstance(second_type_definition, StrawberryObjectDefinition):
             first_origin = second_type_definition.origin
@@ -1057,5 +1037,63 @@ class GraphQLCoreConverter:
 
         raise DuplicatedTypeName(first_origin, second_origin, name)
 
+    def is_same_type_definition(
+        self,
+        first_type_definition: StrawberryObjectDefinition | StrawberryType,
+        second_type_definition: StrawberryObjectDefinition | StrawberryType,
+    ) -> bool:
+        # TODO: maybe move this on the StrawberryType class
+        if (
+            not isinstance(first_type_definition, StrawberryObjectDefinition)
+            or not isinstance(second_type_definition, StrawberryObjectDefinition)
+            or first_type_definition.concrete_of is None
+            or first_type_definition.concrete_of != second_type_definition.concrete_of
+            or (
+                first_type_definition.type_var_map.keys()
+                != second_type_definition.type_var_map.keys()
+            )
+        ):
+            return False
+
+        # manually compare type_var_maps while resolving any lazy types
+        # so that they're considered equal to the actual types they're referencing
+        for type_var, type1 in first_type_definition.type_var_map.items():
+            type2 = second_type_definition.type_var_map[type_var]
+
+            # both lazy types are always resolved because two different lazy types
+            # may be referencing the same actual type
+            if isinstance(type1, LazyType):
+                type1 = type1.resolve_type()  # noqa: PLW2901
+            elif isinstance(type1, StrawberryOptional) and isinstance(
+                type1.of_type, LazyType
+            ):
+                type1.of_type = type1.of_type.resolve_type()
+
+            if isinstance(type2, LazyType):
+                type2 = type2.resolve_type()
+            elif isinstance(type2, StrawberryOptional) and isinstance(
+                type2.of_type, LazyType
+            ):
+                type2.of_type = type2.of_type.resolve_type()
+
+            same_type = type1 == type2
+            # If both types have object definitions, we are handling a nested generic
+            # type like `Foo[Foo[int]]`, meaning we need to compare their type definitions
+            # as they will actually be different instances of the type
+            if (
+                not same_type
+                and has_object_definition(type1)
+                and has_object_definition(type2)
+            ):
+                same_type = self.is_same_type_definition(
+                    type1.__strawberry_definition__,
+                    type2.__strawberry_definition__,
+                )
+
+            if not same_type:
+                return False
+
+        return True
+
 
 __all__ = ["GraphQLCoreConverter"]

strawberry/schema/types/base_scalars.py

@@ -1,8 +1,8 @@
 import datetime
 import decimal
 import uuid
+from collections.abc import Callable
 from operator import methodcaller
-from typing import Callable
 
 import dateutil.parser
 from graphql import GraphQLError

strawberry/schema/types/concrete_type.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, TypeAlias
 
 from graphql import GraphQLField, GraphQLInputField, GraphQLType
 
@@ -11,14 +11,14 @@ if TYPE_CHECKING:
     from strawberry.types.scalar import ScalarDefinition
     from strawberry.types.union import StrawberryUnion
 
-Field = Union[GraphQLInputField, GraphQLField]
+Field: TypeAlias = GraphQLInputField | GraphQLField
 
 
 @dataclasses.dataclass
 class ConcreteType:
-    definition: Union[
-        StrawberryObjectDefinition, EnumDefinition, ScalarDefinition, StrawberryUnion
-    ]
+    definition: (
+        StrawberryObjectDefinition | EnumDefinition | ScalarDefinition | StrawberryUnion
+    )
     implementation: GraphQLType
 
 

strawberry/schema/validation_rules/maybe_null.py

@@ -0,0 +1,136 @@
+from typing import Any
+
+from graphql import (
+    ArgumentNode,
+    GraphQLError,
+    GraphQLNamedType,
+    ObjectValueNode,
+    ValidationContext,
+    ValidationRule,
+    get_named_type,
+)
+
+from strawberry.types.base import StrawberryMaybe, StrawberryOptional
+from strawberry.utils.str_converters import to_camel_case
+
+
+class MaybeNullValidationRule(ValidationRule):
+    """Validates that Maybe[T] fields do not receive explicit null values.
+
+    This rule ensures that:
+    - Maybe[T] fields can only be omitted or have non-null values
+    - Maybe[T | None] fields can be omitted, null, or have non-null values
+
+    This provides clear semantics where Maybe[T] means "either present with value or absent"
+    and Maybe[T | None] means "present with value, present but null, or absent".
+    """
+
+    def __init__(self, validation_context: ValidationContext) -> None:
+        super().__init__(validation_context)
+
+    def enter_argument(self, node: ArgumentNode, *_args: Any) -> None:
+        # Check if this is a null value
+        if node.value.kind != "null_value":
+            return
+
+        # Get the argument definition from the schema
+        argument_def = self.context.get_argument()
+        if not argument_def:
+            return
+
+        # Check if this argument corresponds to a Maybe[T] (not Maybe[T | None])
+        # The argument type extensions should contain the Strawberry type info
+        strawberry_arg_info = argument_def.extensions.get("strawberry-definition")
+        if not strawberry_arg_info:
+            return
+
+        # Get the Strawberry type from the argument info
+        field_type = getattr(strawberry_arg_info, "type", None)
+        if not field_type:
+            return
+
+        if isinstance(field_type, StrawberryMaybe) and not isinstance(
+            field_type.of_type, StrawberryOptional
+        ):
+            # This is Maybe[T] - should not accept null values
+            type_name = self._get_type_name(field_type.of_type)
+
+            self.report_error(
+                GraphQLError(
+                    f"Expected value of type '{type_name}', found null. "
+                    f"Argument '{node.name.value}' of type 'Maybe[{type_name}]' cannot be explicitly set to null. "
+                    f"Use 'Maybe[{type_name} | None]' if you need to allow null values.",
+                    nodes=[node],
+                )
+            )
+
+    def enter_object_value(self, node: ObjectValueNode, *_args: Any) -> None:
+        # Get the input type for this object
+        input_type = get_named_type(self.context.get_input_type())
+        if not input_type:
+            return
+
+        # Get the Strawberry type definition from extensions
+        strawberry_type = input_type.extensions.get("strawberry-definition")
+        if not strawberry_type:
+            return
+
+        # Check each field in the object for null Maybe[T] violations
+        self.validate_maybe_fields(node, input_type, strawberry_type)
+
+    def validate_maybe_fields(
+        self, node: ObjectValueNode, input_type: GraphQLNamedType, strawberry_type: Any
+    ) -> None:
+        # Create a map of field names to field nodes for easy lookup
+        field_node_map = {field.name.value: field for field in node.fields}
+
+        # Check each field in the Strawberry type definition
+        if not hasattr(strawberry_type, "fields"):
+            return
+
+        for field_def in strawberry_type.fields:
+            # Resolve the actual GraphQL field name using the same logic as NameConverter
+            if field_def.graphql_name is not None:
+                field_name = field_def.graphql_name
+            else:
+                # Apply auto_camel_case conversion if enabled (default behavior)
+                field_name = to_camel_case(field_def.python_name)
+
+            # Check if this field is present in the input and has a null value
+            if field_name in field_node_map:
+                field_node = field_node_map[field_name]
+
+                # Check if this field has a null value
+                if field_node.value.kind == "null_value":
+                    # Check if this is a Maybe[T] (not Maybe[T | None])
+                    field_type = field_def.type
+                    if isinstance(field_type, StrawberryMaybe) and not isinstance(
+                        field_type.of_type, StrawberryOptional
+                    ):
+                        # This is Maybe[T] - should not accept null values
+                        type_name = self._get_type_name(field_type.of_type)
+                        self.report_error(
+                            GraphQLError(
+                                f"Expected value of type '{type_name}', found null. "
+                                f"Field '{field_name}' of type 'Maybe[{type_name}]' cannot be explicitly set to null. "
+                                f"Use 'Maybe[{type_name} | None]' if you need to allow null values.",
+                                nodes=[field_node],
+                            )
+                        )
+
+    def _get_type_name(self, type_: Any) -> str:
+        """Get a readable type name for error messages."""
+        if hasattr(type_, "__name__"):
+            return type_.__name__
+        # Handle Strawberry types that don't have __name__
+        if hasattr(type_, "of_type") and hasattr(type_.of_type, "__name__"):
+            # For StrawberryList, StrawberryOptional, etc.
+            return (
+                f"list[{type_.of_type.__name__}]"
+                if "List" in str(type_.__class__)
+                else type_.of_type.__name__
+            )
+        return str(type_)
+
+
+__all__ = ["MaybeNullValidationRule"]

strawberry/schema_codegen/__init__.py

@@ -4,8 +4,8 @@ import dataclasses
 import keyword
 from collections import defaultdict
 from graphlib import TopologicalSorter
-from typing import TYPE_CHECKING, Union
-from typing_extensions import Protocol, TypeAlias
+from typing import TYPE_CHECKING, TypeAlias
+from typing_extensions import Protocol
 
 import libcst as cst
 from graphql import (
@@ -256,7 +256,7 @@ def _get_field(
     )
 
 
-ArgumentValue: TypeAlias = Union[str, bool, list["ArgumentValue"]]
+ArgumentValue: TypeAlias = str | bool | list["ArgumentValue"]
 
 
 def _get_argument_value(argument_value: ConstValueNode) -> ArgumentValue:

strawberry/schema_directive.py

@@ -1,6 +1,7 @@
 import dataclasses
+from collections.abc import Callable
 from enum import Enum
-from typing import Callable, Optional, TypeVar
+from typing import TypeVar
 from typing_extensions import dataclass_transform
 
 from strawberry.types.field import StrawberryField, field
@@ -27,13 +28,13 @@ class Location(Enum):
 @dataclasses.dataclass
 class StrawberrySchemaDirective:
     python_name: str
-    graphql_name: Optional[str]
+    graphql_name: str | None
     locations: list[Location]
     fields: list["StrawberryField"]
-    description: Optional[str] = None
+    description: str | None = None
     repeatable: bool = False
     print_definition: bool = True
-    origin: Optional[type] = None
+    origin: type | None = None
 
 
 T = TypeVar("T", bound=type)
@@ -47,8 +48,8 @@ T = TypeVar("T", bound=type)
 def schema_directive(
     *,
     locations: list[Location],
-    description: Optional[str] = None,
-    name: Optional[str] = None,
+    description: str | None = None,
+    name: str | None = None,
     repeatable: bool = False,
     print_definition: bool = True,
 ) -> Callable[[T], T]:

strawberry/static/graphiql.html

@@ -1,4 +1,4 @@
-<!DOCTYPE html>
+<!doctype html>
 <html>
   <head>
     <title>Strawberry GraphiQL</title>
@@ -61,8 +61,8 @@
     <link
       crossorigin
       rel="stylesheet"
-      href="https://unpkg.com/graphiql@3.0.9/graphiql.min.css"
-      integrity="sha384-yz3/sqpuplkA7msMo0FE4ekg0xdwdvZ8JX9MVZREsxipqjU4h8IRfmAMRcb1QpUy"
+      href="https://unpkg.com/graphiql@3.8.3/graphiql.min.css"
+      integrity="sha384-Mq3vbRBY71jfjQAt/DcjxUIYY33ksal4cgdRt9U/hNPvHBCaT2JfJ/PTRiPKf0aM"
     />
 
     <link
@@ -77,8 +77,8 @@
     <div id="graphiql" class="graphiql-container">Loading...</div>
     <script
       crossorigin
-      src="https://unpkg.com/graphiql@3.0.9/graphiql.min.js"
-      integrity="sha384-Mjte+vxCWz1ZYCzszGHiJqJa5eAxiqI4mc3BErq7eDXnt+UGLXSEW7+i0wmfPiji"
+      src="https://unpkg.com/graphiql@3.8.3/graphiql.min.js"
+      integrity="sha384-HbRVEFG0JGJZeAHCJ9Xm2+tpknBQ7QZmNlO/DgZtkZ0aJSypT96YYGRNod99l9Ie"
     ></script>
     <script
       crossorigin

strawberry/streamable.py

@@ -0,0 +1,35 @@
+from collections.abc import AsyncGenerator
+from typing import Annotated, TypeVar
+
+
+class StrawberryStreamable: ...
+
+
+T = TypeVar("T")
+
+Streamable = Annotated[AsyncGenerator[T, None], StrawberryStreamable()]
+"""Represents a list that can be streamed using @stream.
+
+Example:
+
+```python
+import strawberry
+
+
+@strawberry.type
+class Comment:
+    id: strawberry.ID
+    content: str
+
+
+@strawberry.type
+class Article:
+    @strawberry.field
+    @staticmethod
+    async def comments() -> strawberry.Streamable[Comment]:
+        for comment in fetch_comments():
+            yield comment
+```
+"""
+
+__all__ = ["Streamable"]

strawberry/subscriptions/protocols/graphql_transport_ws/handlers.py

@@ -7,7 +7,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Generic,
-    Optional,
     cast,
 )
 
@@ -34,7 +33,6 @@ from strawberry.types import ExecutionResult
 from strawberry.types.execution import PreExecutionError
 from strawberry.types.graphql import OperationType
 from strawberry.types.unset import UnsetType
-from strawberry.utils.debug import pretty_print_graphql_operation
 from strawberry.utils.operation import get_operation_type
 
 if TYPE_CHECKING:
@@ -53,9 +51,8 @@ class BaseGraphQLTransportWSHandler(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,
         connection_init_wait_timeout: timedelta,
     ) -> None:
         self.view = view
@@ -63,9 +60,8 @@ class BaseGraphQLTransportWSHandler(Generic[Context, RootValue]):
         self.context = context
         self.root_value = root_value
         self.schema = schema
-        self.debug = debug
         self.connection_init_wait_timeout = connection_init_wait_timeout
-        self.connection_init_timeout_task: Optional[asyncio.Task] = None
+        self.connection_init_timeout_task: asyncio.Task | None = None
         self.connection_init_received = False
         self.connection_acknowledged = False
         self.connection_timed_out = False
@@ -237,13 +233,6 @@ class BaseGraphQLTransportWSHandler(Generic[Context, RootValue]):
             await self.websocket.close(code=4409, reason=reason)
             return
 
-        if self.debug:  # pragma: no cover
-            pretty_print_graphql_operation(
-                message["payload"].get("operationName"),
-                message["payload"]["query"],
-                message["payload"].get("variables"),
-            )
-
         operation = Operation(
             self,
             message["id"],
@@ -371,8 +360,8 @@ class Operation(Generic[Context, RootValue]):
         id: str,
         operation_type: OperationType,
         query: str,
-        variables: Optional[dict[str, object]],
-        operation_name: Optional[str],
+        variables: dict[str, object] | None,
+        operation_name: str | None,
     ) -> None:
         self.handler = handler
         self.id = id
@@ -381,7 +370,7 @@ class Operation(Generic[Context, RootValue]):
         self.variables = variables
         self.operation_name = operation_name
         self.completed = False
-        self.task: Optional[asyncio.Task] = None
+        self.task: asyncio.Task | None = None
 
     async def send_operation_message(self, message: Message) -> None:
         if self.completed: