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

strawberry/types/enum.py

@@ -1,12 +1,9 @@
 import dataclasses
-from collections.abc import Iterable, Mapping
+from collections.abc import Callable, Iterable, Mapping
 from enum import EnumMeta
 from typing import (
     Any,
-    Callable,
-    Optional,
     TypeVar,
-    Union,
     overload,
 )
 
@@ -18,9 +15,9 @@ from strawberry.types.base import StrawberryType
 class EnumValue:
     name: str
     value: Any
-    deprecation_reason: Optional[str] = None
+    deprecation_reason: str | None = None
     directives: Iterable[object] = ()
-    description: Optional[str] = None
+    description: str | None = None
 
 
 @dataclasses.dataclass
@@ -28,7 +25,7 @@ class EnumDefinition(StrawberryType):
     wrapped_cls: EnumMeta
     name: str
     values: list[EnumValue]
-    description: Optional[str]
+    description: str | None
     directives: Iterable[object] = ()
 
     def __hash__(self) -> int:
@@ -36,8 +33,8 @@ class EnumDefinition(StrawberryType):
         return hash(self.name)
 
     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:
         # enum don't support type parameters, so we can safely return self
         return self
 
@@ -54,10 +51,10 @@ class EnumDefinition(StrawberryType):
 @dataclasses.dataclass
 class EnumValueDefinition:
     value: Any
-    graphql_name: Optional[str] = None
-    deprecation_reason: Optional[str] = None
+    graphql_name: str | None = None
+    deprecation_reason: str | None = None
     directives: Iterable[object] = ()
-    description: Optional[str] = None
+    description: str | None = None
 
     def __int__(self) -> int:
         return self.value
@@ -65,10 +62,10 @@ class EnumValueDefinition:
 
 def enum_value(
     value: Any,
-    name: Optional[str] = None,
-    deprecation_reason: Optional[str] = None,
+    name: str | None = None,
+    deprecation_reason: str | None = None,
     directives: Iterable[object] = (),
-    description: Optional[str] = None,
+    description: str | None = None,
 ) -> EnumValueDefinition:
     """Function to customise an enum value, for example to add a description or deprecation reason.
 
@@ -109,8 +106,8 @@ EnumType = TypeVar("EnumType", bound=EnumMeta)
 
 def _process_enum(
     cls: EnumType,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
     directives: Iterable[object] = (),
 ) -> EnumType:
     if not isinstance(cls, EnumMeta):
@@ -166,8 +163,8 @@ def _process_enum(
 def enum(
     cls: EnumType,
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
     directives: Iterable[object] = (),
 ) -> EnumType: ...
 
@@ -176,19 +173,19 @@ def enum(
 def enum(
     cls: None = None,
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
     directives: Iterable[object] = (),
 ) -> Callable[[EnumType], EnumType]: ...
 
 
 def enum(
-    cls: Optional[EnumType] = None,
+    cls: EnumType | None = None,
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
     directives: Iterable[object] = (),
-) -> Union[EnumType, Callable[[EnumType], EnumType]]:
+) -> EnumType | Callable[[EnumType], EnumType]:
     """Annotates an Enum class a GraphQL enum.
 
     GraphQL enums only have names, while Python enums have names and values,

strawberry/types/execution.py

@@ -4,10 +4,9 @@ import dataclasses
 from typing import (
     TYPE_CHECKING,
     Any,
-    Optional,
     runtime_checkable,
 )
-from typing_extensions import Protocol, TypedDict
+from typing_extensions import Protocol, TypedDict, deprecated
 
 from graphql import specified_rules
 
@@ -18,47 +17,47 @@ if TYPE_CHECKING:
     from typing_extensions import NotRequired
 
     from graphql import ASTValidationRule
-    from graphql import ExecutionResult as GraphQLExecutionResult
     from graphql.error.graphql_error import GraphQLError
     from graphql.language import DocumentNode, OperationDefinitionNode
 
     from strawberry.schema import Schema
+    from strawberry.schema._graphql_core import GraphQLExecutionResult
 
     from .graphql import OperationType
 
 
 @dataclasses.dataclass
 class ExecutionContext:
-    query: Optional[str]
+    query: str | None
     schema: Schema
     allowed_operations: Iterable[OperationType]
     context: Any = None
-    variables: Optional[dict[str, Any]] = None
+    variables: dict[str, Any] | None = None
     parse_options: ParseOptions = dataclasses.field(
         default_factory=lambda: ParseOptions()
     )
-    root_value: Optional[Any] = None
+    root_value: Any | None = None
     validation_rules: tuple[type[ASTValidationRule], ...] = dataclasses.field(
         default_factory=lambda: tuple(specified_rules)
     )
 
     # The operation name that is provided by the request
-    provided_operation_name: dataclasses.InitVar[Optional[str]] = None
+    provided_operation_name: dataclasses.InitVar[str | None] = None
 
     # Values that get populated during the GraphQL execution so that they can be
     # accessed by extensions
-    graphql_document: Optional[DocumentNode] = None
-    errors: Optional[list[GraphQLError]] = None
-    result: Optional[GraphQLExecutionResult] = None
+    graphql_document: DocumentNode | None = None
+    pre_execution_errors: list[GraphQLError] | None = None
+    result: GraphQLExecutionResult | None = None
     extensions_results: dict[str, Any] = dataclasses.field(default_factory=dict)
 
-    operation_extensions: Optional[dict[str, Any]] = None
+    operation_extensions: dict[str, Any] | None = None
 
     def __post_init__(self, provided_operation_name: str | None) -> None:
         self._provided_operation_name = provided_operation_name
 
     @property
-    def operation_name(self) -> Optional[str]:
+    def operation_name(self) -> str | None:
         if self._provided_operation_name is not None:
             return self._provided_operation_name
 
@@ -79,19 +78,25 @@ class ExecutionContext:
 
         return get_operation_type(graphql_document, self.operation_name)
 
-    def _get_first_operation(self) -> Optional[OperationDefinitionNode]:
+    def _get_first_operation(self) -> OperationDefinitionNode | None:
         graphql_document = self.graphql_document
         if not graphql_document:
             return None
 
         return get_first_operation(graphql_document)
 
+    @property
+    @deprecated("Use 'pre_execution_errors' instead")
+    def errors(self) -> list[GraphQLError] | None:
+        """Deprecated: Use pre_execution_errors instead."""
+        return self.pre_execution_errors
+
 
 @dataclasses.dataclass
 class ExecutionResult:
-    data: Optional[dict[str, Any]]
-    errors: Optional[list[GraphQLError]]
-    extensions: Optional[dict[str, Any]] = None
+    data: dict[str, Any] | None
+    errors: list[GraphQLError] | None
+    extensions: dict[str, Any] | None = None
 
 
 @dataclasses.dataclass

strawberry/types/field.py

@@ -4,16 +4,15 @@ import contextlib
 import copy
 import dataclasses
 import sys
-from collections.abc import Awaitable, Coroutine, Mapping, Sequence
+from collections.abc import Awaitable, Callable, Coroutine, Mapping, Sequence
 from functools import cached_property
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Optional,
+    NoReturn,
+    TypeAlias,
     TypeVar,
     Union,
-    cast,
     overload,
 )
 
@@ -30,7 +29,8 @@ from .fields.resolver import StrawberryResolver
 
 if TYPE_CHECKING:
     import builtins
-    from typing_extensions import Literal, Self
+    from typing import Literal
+    from typing_extensions import Self
 
     from strawberry.extensions.field_extension import FieldExtension
     from strawberry.permission import BasePermission
@@ -40,24 +40,31 @@ if TYPE_CHECKING:
 
 T = TypeVar("T")
 
-_RESOLVER_TYPE_SYNC = Union[
+_RESOLVER_TYPE_SYNC: TypeAlias = Union[
     StrawberryResolver[T],
     Callable[..., T],
     "staticmethod[Any, T]",
     "classmethod[Any, Any, T]",
 ]
 
-_RESOLVER_TYPE_ASYNC = Union[
-    Callable[..., Coroutine[Any, Any, T]],
-    Callable[..., Awaitable[T]],
-]
+_RESOLVER_TYPE_ASYNC: TypeAlias = (
+    Callable[..., Coroutine[Any, Any, T]] | Callable[..., Awaitable[T]]
+)
 
-_RESOLVER_TYPE = Union[_RESOLVER_TYPE_SYNC[T], _RESOLVER_TYPE_ASYNC[T]]
+_RESOLVER_TYPE: TypeAlias = _RESOLVER_TYPE_SYNC[T] | _RESOLVER_TYPE_ASYNC[T]
 
-UNRESOLVED = object()
 
+class UNRESOLVED:
+    def __new__(cls) -> NoReturn:
+        raise TypeError("UNRESOLVED is a sentinel and cannot be instantiated.")
 
-def _is_generic(resolver_type: Union[StrawberryType, type]) -> bool:
+
+FieldType: TypeAlias = (
+    StrawberryType | type[WithStrawberryObjectDefinition | UNRESOLVED]
+)
+
+
+def _is_generic(resolver_type: StrawberryType | type) -> bool:
     """Returns True if `resolver_type` is generic else False."""
     if isinstance(resolver_type, StrawberryType):
         return resolver_type.is_graphql_generic
@@ -70,34 +77,36 @@ def _is_generic(resolver_type: Union[StrawberryType, type]) -> bool:
 
 
 class StrawberryField(dataclasses.Field):
-    type_annotation: Optional[StrawberryAnnotation]
+    type_annotation: StrawberryAnnotation | None
     default_resolver: Callable[[Any, str], object] = getattr
 
     def __init__(
         self,
-        python_name: Optional[str] = None,
-        graphql_name: Optional[str] = None,
-        type_annotation: Optional[StrawberryAnnotation] = None,
-        origin: Optional[Union[type, Callable, staticmethod, classmethod]] = None,
+        python_name: str | None = None,
+        graphql_name: str | None = None,
+        type_annotation: StrawberryAnnotation | None = None,
+        origin: type | Callable | staticmethod | classmethod | None = None,
         is_subscription: bool = False,
-        description: Optional[str] = None,
-        base_resolver: Optional[StrawberryResolver] = None,
+        description: str | None = None,
+        base_resolver: StrawberryResolver | None = None,
         permission_classes: list[type[BasePermission]] = (),  # type: ignore
         default: object = dataclasses.MISSING,
-        default_factory: Union[Callable[[], Any], object] = dataclasses.MISSING,
-        metadata: Optional[Mapping[Any, Any]] = None,
-        deprecation_reason: Optional[str] = None,
+        default_factory: Callable[[], Any] | object = dataclasses.MISSING,
+        metadata: Mapping[Any, Any] | None = None,
+        deprecation_reason: str | None = None,
         directives: Sequence[object] = (),
         extensions: list[FieldExtension] = (),  # type: ignore
     ) -> None:
         # basic fields are fields with no provided resolver
         is_basic_field = not base_resolver
 
-        kwargs: Any = {}
+        kwargs: Any = {
+            "kw_only": True,
+        }
 
-        # kw_only was added to python 3.10 and it is required
-        if sys.version_info >= (3, 10):
-            kwargs["kw_only"] = dataclasses.MISSING
+        # doc was added to python 3.14 and it is required
+        if sys.version_info >= (3, 14):
+            kwargs["doc"] = None
 
         super().__init__(
             default=default,
@@ -116,11 +125,11 @@ class StrawberryField(dataclasses.Field):
 
         self.type_annotation = type_annotation
 
-        self.description: Optional[str] = description
+        self.description: str | None = description
         self.origin = origin
 
-        self._arguments: Optional[list[StrawberryArgument]] = None
-        self._base_resolver: Optional[StrawberryResolver] = None
+        self._arguments: list[StrawberryArgument] | None = None
+        self._base_resolver: StrawberryResolver | None = None
         if base_resolver is not None:
             self.base_resolver = base_resolver
 
@@ -212,8 +221,8 @@ class StrawberryField(dataclasses.Field):
         return self
 
     def get_result(
-        self, source: Any, info: Optional[Info], args: list[Any], kwargs: Any
-    ) -> Union[Awaitable[Any], Any]:
+        self, source: Any, info: Info | None, args: list[Any], kwargs: Any
+    ) -> Awaitable[Any] | Any:
         """Calls the resolver defined for the StrawberryField.
 
         If the field doesn't have a resolver defined we default
@@ -255,7 +264,7 @@ class StrawberryField(dataclasses.Field):
             else _is_generic(self.type)
         )
 
-    def _python_name(self) -> Optional[str]:
+    def _python_name(self) -> str | None:
         if self.name:
             return self.name
 
@@ -270,7 +279,7 @@ class StrawberryField(dataclasses.Field):
     python_name: str = property(_python_name, _set_python_name)  # type: ignore[assignment]
 
     @property
-    def base_resolver(self) -> Optional[StrawberryResolver]:
+    def base_resolver(self) -> StrawberryResolver | None:
         return self._base_resolver
 
     @base_resolver.setter
@@ -293,14 +302,8 @@ class StrawberryField(dataclasses.Field):
         #       removed.
         _ = resolver.arguments
 
-    @property  # type: ignore
-    def type(
-        self,
-    ) -> Union[  # type: ignore [valid-type]
-        StrawberryType,
-        type[WithStrawberryObjectDefinition],
-        Literal[UNRESOLVED],
-    ]:
+    @property
+    def type(self) -> FieldType:
         return self.resolve_type()
 
     @type.setter
@@ -330,15 +333,11 @@ class StrawberryField(dataclasses.Field):
     def resolve_type(
         self,
         *,
-        type_definition: Optional[StrawberryObjectDefinition] = None,
-    ) -> Union[  # type: ignore [valid-type]
-        StrawberryType,
-        type[WithStrawberryObjectDefinition],
-        Literal[UNRESOLVED],
-    ]:
+        type_definition: StrawberryObjectDefinition | None = None,
+    ) -> FieldType:
         # We return UNRESOLVED by default, which means this case will raise a
         # MissingReturnAnnotationError exception in _check_field_annotations
-        resolved = UNRESOLVED
+        resolved: FieldType = UNRESOLVED  # type: ignore[assignment]
 
         # We are catching NameError because dataclasses tries to fetch the type
         # of the field from the class before the class is fully defined.
@@ -348,7 +347,7 @@ class StrawberryField(dataclasses.Field):
         with contextlib.suppress(NameError):
             # Prioritise the field type over the resolver return type
             if self.type_annotation is not None:
-                resolved = self.type_annotation.resolve()
+                resolved = self.type_annotation.resolve(type_definition=type_definition)
             elif self.base_resolver is not None and self.base_resolver.type is not None:
                 # Handle unannotated functions (such as lambdas)
                 # Generics will raise MissingTypesForGenericError later
@@ -356,36 +355,16 @@ class StrawberryField(dataclasses.Field):
                 # which is the same behaviour as having no type information.
                 resolved = self.base_resolver.type
 
-        # If this is a generic field, try to resolve it using its origin's
-        # specialized type_var_map
-        # TODO: should we check arguments here too?
-        if _is_generic(resolved):  # type: ignore
-            specialized_type_var_map = (
-                type_definition and type_definition.specialized_type_var_map
-            )
-            if specialized_type_var_map and isinstance(resolved, StrawberryType):
-                resolved = resolved.copy_with(specialized_type_var_map)
-
-            # If the field is still generic, try to resolve it from the type_definition
-            # that is asking for it.
-            if (
-                _is_generic(cast("Union[StrawberryType, type]", resolved))
-                and type_definition is not None
-                and type_definition.type_var_map
-                and isinstance(resolved, StrawberryType)
-            ):
-                resolved = resolved.copy_with(type_definition.type_var_map)
-
         return resolved
 
     def copy_with(
-        self, type_var_map: Mapping[str, Union[StrawberryType, builtins.type]]
+        self, type_var_map: Mapping[str, StrawberryType | builtins.type]
     ) -> Self:
         new_field = copy.copy(self)
 
-        override_type: Optional[
-            Union[StrawberryType, type[WithStrawberryObjectDefinition]]
-        ] = None
+        override_type: StrawberryType | type[WithStrawberryObjectDefinition] | None = (
+            None
+        )
         type_ = self.resolve_type()
         if has_object_definition(type_):
             type_definition = type_.__strawberry_definition__
@@ -426,18 +405,18 @@ class StrawberryField(dataclasses.Field):
 def field(
     *,
     resolver: _RESOLVER_TYPE_ASYNC[T],
-    name: Optional[str] = None,
+    name: str | None = None,
     is_subscription: bool = False,
-    description: Optional[str] = None,
+    description: str | None = None,
     init: Literal[False] = False,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
 ) -> T: ...
 
 
@@ -445,36 +424,36 @@ def field(
 def field(
     *,
     resolver: _RESOLVER_TYPE_SYNC[T],
-    name: Optional[str] = None,
+    name: str | None = None,
     is_subscription: bool = False,
-    description: Optional[str] = None,
+    description: str | None = None,
     init: Literal[False] = False,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
 ) -> T: ...
 
 
 @overload
 def field(
     *,
-    name: Optional[str] = None,
+    name: str | None = None,
     is_subscription: bool = False,
-    description: Optional[str] = None,
+    description: str | None = None,
     init: Literal[True] = True,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
 ) -> Any: ...
 
 
@@ -482,17 +461,17 @@ def field(
 def field(
     resolver: _RESOLVER_TYPE_ASYNC[T],
     *,
-    name: Optional[str] = None,
+    name: str | None = None,
     is_subscription: bool = False,
-    description: Optional[str] = None,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    description: str | None = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
 ) -> StrawberryField: ...
 
 
@@ -500,38 +479,38 @@ def field(
 def field(
     resolver: _RESOLVER_TYPE_SYNC[T],
     *,
-    name: Optional[str] = None,
+    name: str | None = None,
     is_subscription: bool = False,
-    description: Optional[str] = None,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    description: str | None = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
 ) -> StrawberryField: ...
 
 
 def field(
-    resolver: Optional[_RESOLVER_TYPE[Any]] = None,
+    resolver: _RESOLVER_TYPE[Any] | None = None,
     *,
-    name: Optional[str] = None,
+    name: str | None = None,
     is_subscription: bool = False,
-    description: Optional[str] = None,
-    permission_classes: Optional[list[type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
+    description: str | None = None,
+    permission_classes: list[type[BasePermission]] | None = None,
+    deprecation_reason: str | None = None,
     default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: Optional[list[FieldExtension]] = None,
-    graphql_type: Optional[Any] = None,
+    default_factory: Callable[..., object] | object = dataclasses.MISSING,
+    metadata: Mapping[Any, Any] | None = None,
+    directives: Sequence[object] | None = (),
+    extensions: list[FieldExtension] | None = None,
+    graphql_type: Any | None = None,
     # This init parameter is used by PyRight to determine whether this field
     # is added in the constructor or not. It is not used to change
     # any behavior at the moment.
-    init: Literal[True, False, None] = None,
+    init: Literal[True, False] | None = None,
 ) -> Any:
     """Annotates a method or property as a GraphQL field.