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

strawberry/types/object_type.py

@@ -1,18 +1,14 @@
 import builtins
 import dataclasses
 import inspect
-import sys
 import types
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from typing import (
     Any,
-    Callable,
-    Optional,
     TypeVar,
-    Union,
     overload,
 )
-from typing_extensions import dataclass_transform
+from typing_extensions import dataclass_transform, get_annotations
 
 from strawberry.exceptions import (
     InvalidSuperclassInterfaceError,
@@ -51,7 +47,8 @@ def _check_field_annotations(cls: builtins.type[Any]) -> None:
 
     https://github.com/python/cpython/blob/6fed3c85402c5ca704eb3f3189ca3f5c67a08d19/Lib/dataclasses.py#L881-L884
     """
-    cls_annotations = cls.__dict__.get("__annotations__", {})
+    cls_annotations = get_annotations(cls)
+    # TODO: do we need this?
     cls.__annotations__ = cls_annotations
 
     for field_name, field_ in cls.__dict__.items():
@@ -104,24 +101,7 @@ def _wrap_dataclass(cls: builtins.type[T]) -> builtins.type[T]:
     """Wrap a strawberry.type class with a dataclass and check for any issues before doing so."""
     # Ensure all Fields have been properly type-annotated
     _check_field_annotations(cls)
-
-    dclass_kwargs: dict[str, bool] = {}
-
-    # Python 3.10 introduces the kw_only param. If we're on an older version
-    # then generate our own custom init function
-    if sys.version_info >= (3, 10):
-        dclass_kwargs["kw_only"] = True
-    else:
-        dclass_kwargs["init"] = False
-
-    dclass = dataclasses.dataclass(cls, **dclass_kwargs)
-
-    if sys.version_info < (3, 10):
-        from strawberry.utils.dataclasses import add_custom_init_fn
-
-        add_custom_init_fn(dclass)
-
-    return dclass
+    return dataclasses.dataclass(kw_only=True)(cls)
 
 
 def _inject_default_for_maybe_annotations(
@@ -136,13 +116,13 @@ def _inject_default_for_maybe_annotations(
 def _process_type(
     cls: T,
     *,
-    name: Optional[str] = None,
+    name: str | None = None,
     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,
-    original_type_annotations: Optional[dict[str, Any]] = None,
+    original_type_annotations: dict[str, Any] | None = None,
 ) -> T:
     name = name or to_camel_case(cls.__name__)
     original_type_annotations = original_type_annotations or {}
@@ -208,11 +188,11 @@ def _process_type(
 def type(
     cls: T,
     *,
-    name: Optional[str] = None,
+    name: str | None = None,
     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,
 ) -> T: ...
 
@@ -223,25 +203,25 @@ def type(
 )
 def type(
     *,
-    name: Optional[str] = None,
+    name: str | None = None,
     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,
 ) -> Callable[[T], T]: ...
 
 
 def type(
-    cls: Optional[T] = None,
+    cls: T | None = None,
     *,
-    name: Optional[str] = None,
+    name: str | None = None,
     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,
-) -> Union[T, Callable[[T], T]]:
+) -> T | Callable[[T], T]:
     """Annotates a class as a GraphQL type.
 
     Similar to `dataclasses.dataclass`, but with additional functionality for
@@ -330,10 +310,10 @@ def type(
 def input(
     cls: T,
     *,
-    name: Optional[str] = None,
-    one_of: Optional[bool] = None,
-    description: Optional[str] = None,
-    directives: Optional[Sequence[object]] = (),
+    name: str | None = None,
+    one_of: bool | None = None,
+    description: str | None = None,
+    directives: Sequence[object] | None = (),
 ) -> T: ...
 
 
@@ -343,20 +323,20 @@ def input(
 )
 def input(
     *,
-    name: Optional[str] = None,
-    one_of: Optional[bool] = None,
-    description: Optional[str] = None,
-    directives: Optional[Sequence[object]] = (),
+    name: str | None = None,
+    one_of: bool | None = None,
+    description: str | None = None,
+    directives: Sequence[object] | None = (),
 ) -> Callable[[T], T]: ...
 
 
 def input(
-    cls: Optional[T] = None,
+    cls: T | None = None,
     *,
-    name: Optional[str] = None,
-    one_of: Optional[bool] = None,
-    description: Optional[str] = None,
-    directives: Optional[Sequence[object]] = (),
+    name: str | None = None,
+    one_of: bool | None = None,
+    description: str | None = None,
+    directives: Sequence[object] | None = (),
 ):
     """Annotates a class as a GraphQL Input type.
 
@@ -409,9 +389,9 @@ def input(
 def interface(
     cls: T,
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    directives: Optional[Sequence[object]] = (),
+    name: str | None = None,
+    description: str | None = None,
+    directives: Sequence[object] | None = (),
 ) -> T: ...
 
 
@@ -421,9 +401,9 @@ def interface(
 )
 def interface(
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    directives: Optional[Sequence[object]] = (),
+    name: str | None = None,
+    description: str | None = None,
+    directives: Sequence[object] | None = (),
 ) -> Callable[[T], T]: ...
 
 
@@ -431,11 +411,11 @@ def interface(
     order_default=True, kw_only_default=True, field_specifiers=(field, StrawberryField)
 )
 def interface(
-    cls: Optional[T] = None,
+    cls: T | None = None,
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    directives: Optional[Sequence[object]] = (),
+    name: str | None = None,
+    description: str | None = None,
+    directives: Sequence[object] | None = (),
 ):
     """Annotates a class as a GraphQL Interface.
 

strawberry/types/scalar.py

@@ -5,11 +5,9 @@ from dataclasses import dataclass
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     NewType,
     Optional,
     TypeVar,
-    Union,
     overload,
 )
 
@@ -18,16 +16,12 @@ from strawberry.types.base import StrawberryType
 from strawberry.utils.str_converters import to_camel_case
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable, Mapping
+    from collections.abc import Callable, Iterable, Mapping
 
     from graphql import GraphQLScalarType
 
 
-# in python 3.10+ NewType is a class
-if sys.version_info >= (3, 10):
-    _T = TypeVar("_T", bound=Union[type, NewType])
-else:
-    _T = TypeVar("_T", bound=type)
+_T = TypeVar("_T", bound=type | NewType)
 
 
 def identity(x: _T) -> _T:
@@ -37,25 +31,25 @@ def identity(x: _T) -> _T:
 @dataclass
 class ScalarDefinition(StrawberryType):
     name: str
-    description: Optional[str]
-    specified_by_url: Optional[str]
-    serialize: Optional[Callable]
-    parse_value: Optional[Callable]
-    parse_literal: Optional[Callable]
+    description: str | None
+    specified_by_url: str | None
+    serialize: Callable | None
+    parse_value: Callable | None
+    parse_literal: Callable | None
     directives: Iterable[object] = ()
-    origin: Optional[GraphQLScalarType | type] = None
+    origin: GraphQLScalarType | type | None = None
 
     # Optionally store the GraphQLScalarType instance so that we don't get
     # duplicates
-    implementation: Optional[GraphQLScalarType] = None
+    implementation: GraphQLScalarType | None = None
 
     # used for better error messages
-    _source_file: Optional[str] = None
-    _source_line: Optional[int] = None
+    _source_file: str | None = None
+    _source_line: int | None = None
 
     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 super().copy_with(type_var_map)  # type: ignore[safe-super]
 
     @property
@@ -72,10 +66,10 @@ class ScalarWrapper:
     def __call__(self, *args: str, **kwargs: Any) -> Any:
         return self.wrap(*args, **kwargs)
 
-    def __or__(self, other: Union[StrawberryType, type]) -> StrawberryType:
+    def __or__(self, other: StrawberryType | type) -> StrawberryType:
         if other is None:
             # Return the correct notation when using `StrawberryUnion | None`.
-            return Optional[self]
+            return Optional[self]  # noqa: UP045
 
         # Raise an error in any other case.
         # There is Work in progress to deal with more merging cases, see:
@@ -86,12 +80,12 @@ class ScalarWrapper:
 def _process_scalar(
     cls: _T,
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    specified_by_url: Optional[str] = None,
-    serialize: Optional[Callable] = None,
-    parse_value: Optional[Callable] = None,
-    parse_literal: Optional[Callable] = None,
+    name: str | None = None,
+    description: str | None = None,
+    specified_by_url: str | None = None,
+    serialize: Callable | None = None,
+    parse_value: Callable | None = None,
+    parse_literal: Callable | None = None,
     directives: Iterable[object] = (),
 ) -> ScalarWrapper:
     from strawberry.exceptions.handler import should_use_rich_exceptions
@@ -127,12 +121,12 @@ def _process_scalar(
 @overload
 def scalar(
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    specified_by_url: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
+    specified_by_url: str | None = None,
     serialize: Callable = identity,
-    parse_value: Optional[Callable] = None,
-    parse_literal: Optional[Callable] = None,
+    parse_value: Callable | None = None,
+    parse_literal: Callable | None = None,
     directives: Iterable[object] = (),
 ) -> Callable[[_T], _T]: ...
 
@@ -141,12 +135,12 @@ def scalar(
 def scalar(
     cls: _T,
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    specified_by_url: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
+    specified_by_url: str | None = None,
     serialize: Callable = identity,
-    parse_value: Optional[Callable] = None,
-    parse_literal: Optional[Callable] = None,
+    parse_value: Callable | None = None,
+    parse_literal: Callable | None = None,
     directives: Iterable[object] = (),
 ) -> _T: ...
 
@@ -155,14 +149,14 @@ def scalar(
 # here or else it won't let us use any custom scalar to annotate attributes in
 # dataclasses/types. This should be properly solved when implementing StrawberryScalar
 def scalar(
-    cls: Optional[_T] = None,
+    cls: _T | None = None,
     *,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    specified_by_url: Optional[str] = None,
+    name: str | None = None,
+    description: str | None = None,
+    specified_by_url: str | None = None,
     serialize: Callable = identity,
-    parse_value: Optional[Callable] = None,
-    parse_literal: Optional[Callable] = None,
+    parse_value: Callable | None = None,
+    parse_literal: Callable | None = None,
     directives: Iterable[object] = (),
 ) -> Any:
     """Annotates a class or type as a GraphQL custom scalar.

strawberry/types/union.py

@@ -9,12 +9,10 @@ from typing import (
     Annotated,
     Any,
     NoReturn,
-    Optional,
     TypeVar,
-    Union,
     cast,
+    get_origin,
 )
-from typing_extensions import get_origin
 
 from graphql import GraphQLNamedType, GraphQLUnionType
 
@@ -48,14 +46,14 @@ if TYPE_CHECKING:
 
 class StrawberryUnion(StrawberryType):
     # used for better error messages
-    _source_file: Optional[str] = None
-    _source_line: Optional[int] = None
+    _source_file: str | None = None
+    _source_line: int | None = None
 
     def __init__(
         self,
-        name: Optional[str] = None,
+        name: str | None = None,
         type_annotations: tuple[StrawberryAnnotation, ...] = (),
-        description: Optional[str] = None,
+        description: str | None = None,
         directives: Iterable[object] = (),
     ) -> None:
         self.graphql_name = name
@@ -64,7 +62,7 @@ class StrawberryUnion(StrawberryType):
         self.directives = directives
         self._source_file = None
         self._source_line = None
-        self.concrete_of: Optional[StrawberryUnion] = None
+        self.concrete_of: StrawberryUnion | None = None
 
     def __eq__(self, other: object) -> bool:
         if isinstance(other, StrawberryType):
@@ -81,7 +79,7 @@ class StrawberryUnion(StrawberryType):
     def __hash__(self) -> int:
         return hash((self.graphql_name, self.type_annotations, self.description))
 
-    def __or__(self, other: Union[StrawberryType, type]) -> StrawberryType:
+    def __or__(self, other: StrawberryType | type) -> StrawberryType:
         # TODO: this will be removed in future versions, you should
         # use Annotated[Union[...], strawberry.union(...)] instead
 
@@ -131,7 +129,7 @@ class StrawberryUnion(StrawberryType):
         return any(map(_is_generic, self.types))
 
     def copy_with(
-        self, type_var_map: Mapping[str, Union[StrawberryType, type]]
+        self, type_var_map: Mapping[str, StrawberryType | type]
     ) -> StrawberryType:
         if not self.is_graphql_generic:
             return self
@@ -139,7 +137,7 @@ class StrawberryUnion(StrawberryType):
         new_types = []
 
         for type_ in self.types:
-            new_type: Union[StrawberryType, type]
+            new_type: StrawberryType | type
 
             if has_object_definition(type_):
                 type_definition = type_.__strawberry_definition__
@@ -189,7 +187,7 @@ class StrawberryUnion(StrawberryType):
                 # Couldn't resolve using `is_type_of`
                 raise WrongReturnTypeForUnion(info.field_name, str(type(root)))
 
-            return_type: Optional[GraphQLType]
+            return_type: GraphQLType | None
 
             # Iterate over all of our known types and find the first concrete
             # type that implements the type. We prioritise checking types named in the
@@ -242,9 +240,9 @@ class StrawberryUnion(StrawberryType):
 
 def union(
     name: str,
-    types: Optional[Collection[type[Any]]] = None,
+    types: Collection[type[Any]] | None = None,
     *,
-    description: Optional[str] = None,
+    description: str | None = None,
     directives: Iterable[object] = (),
 ) -> StrawberryUnion:
     """Creates a new named Union type.

strawberry/utils/aio.py

@@ -1,12 +1,15 @@
 import sys
-from collections.abc import AsyncGenerator, AsyncIterable, AsyncIterator, Awaitable
+from collections.abc import (
+    AsyncGenerator,
+    AsyncIterable,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+)
 from contextlib import asynccontextmanager, suppress
 from typing import (
     Any,
-    Callable,
-    Optional,
     TypeVar,
-    Union,
     cast,
 )
 
@@ -30,7 +33,7 @@ async def aclosing(thing: _T) -> AsyncGenerator[_T, None]:
 
 
 async def aenumerate(
-    iterable: Union[AsyncIterator[_T], AsyncIterable[_T]],
+    iterable: AsyncIterator[_T] | AsyncIterable[_T],
 ) -> AsyncIterator[tuple[int, _T]]:
     """Async version of enumerate."""
     i = 0
@@ -40,10 +43,10 @@ async def aenumerate(
 
 
 async def aislice(
-    aiterable: Union[AsyncIterator[_T], AsyncIterable[_T]],
-    start: Optional[int] = None,
-    stop: Optional[int] = None,
-    step: Optional[int] = None,
+    aiterable: AsyncIterator[_T] | AsyncIterable[_T],
+    start: int | None = None,
+    stop: int | None = None,
+    step: int | None = None,
 ) -> AsyncIterator[_T]:
     """Async version of itertools.islice."""
     # This is based on

strawberry/utils/await_maybe.py

@@ -1,11 +1,11 @@
 import inspect
 from collections.abc import AsyncIterator, Awaitable, Iterator
-from typing import TypeVar, Union
+from typing import TypeAlias, TypeVar
 
 T = TypeVar("T")
 
-AwaitableOrValue = Union[Awaitable[T], T]
-AsyncIteratorOrIterator = Union[AsyncIterator[T], Iterator[T]]
+AwaitableOrValue: TypeAlias = Awaitable[T] | T
+AsyncIteratorOrIterator: TypeAlias = AsyncIterator[T] | Iterator[T]
 
 
 async def await_maybe(value: AwaitableOrValue[T]) -> T:

strawberry/utils/deprecations.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import warnings
-from typing import Any, Optional
+from typing import Any
 
 
 class DEPRECATION_MESSAGES:  # noqa: N801
@@ -19,7 +19,7 @@ class DeprecatedDescriptor:
     def warn(self) -> None:
         warnings.warn(self.msg, stacklevel=2)
 
-    def __get__(self, obj: Optional[object], type: Optional[type] = None) -> Any:
+    def __get__(self, obj: object | None, type: type | None = None) -> Any:
         self.warn()
         return self.alias
 

strawberry/utils/importer.py

@@ -1,9 +1,8 @@
 import importlib
-from typing import Optional
 
 
 def import_module_symbol(
-    selector: str, default_symbol_name: Optional[str] = None
+    selector: str, default_symbol_name: str | None = None
 ) -> object:
     if ":" in selector:
         module_name, symbol_name = selector.split(":", 1)

strawberry/utils/inspect.py

@@ -1,14 +1,12 @@
 import asyncio
 import inspect
+from collections.abc import Callable
 from functools import lru_cache
 from typing import (
     Any,
-    Callable,
     Generic,
-    Optional,
     Protocol,
     TypeVar,
-    Union,
     get_args,
     get_origin,
 )
@@ -39,7 +37,7 @@ def get_func_args(func: Callable[[Any], Any]) -> list[str]:
     ]
 
 
-def get_specialized_type_var_map(cls: type) -> Optional[dict[str, type]]:
+def get_specialized_type_var_map(cls: type) -> dict[str, type] | None:
     """Get a type var map for specialized types.
 
     Consider the following:
@@ -84,7 +82,7 @@ def get_specialized_type_var_map(cls: type) -> Optional[dict[str, type]]:
     """
     from strawberry.types.base import has_object_definition
 
-    param_args: dict[TypeVar, Union[TypeVar, type]] = {}
+    param_args: dict[TypeVar, TypeVar | type] = {}
 
     types: list[type] = [cls]
     while types:
@@ -99,7 +97,7 @@ def get_specialized_type_var_map(cls: type) -> Optional[dict[str, type]]:
         if (type_params := getattr(origin, "__parameters__", None)) is not None:
             args = get_args(tp)
             if args:
-                for type_param, arg in zip(type_params, args):
+                for type_param, arg in zip(type_params, args, strict=True):
                     if type_param not in param_args:
                         param_args[type_param] = arg
             else:

strawberry/utils/logging.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from typing import Final
@@ -18,7 +18,7 @@ class StrawberryLogger:
     def error(
         cls,
         error: GraphQLError,
-        execution_context: Optional[ExecutionContext] = None,
+        execution_context: ExecutionContext | None = None,
         # https://www.python.org/dev/peps/pep-0484/#arbitrary-argument-lists-and-default-argument-values
         **logger_kwargs: Any,
     ) -> None:

strawberry/utils/operation.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from graphql.language import OperationDefinitionNode
 
@@ -12,7 +12,7 @@ if TYPE_CHECKING:
 
 def get_first_operation(
     graphql_document: DocumentNode,
-) -> Optional[OperationDefinitionNode]:
+) -> OperationDefinitionNode | None:
     for definition in graphql_document.definitions:
         if isinstance(definition, OperationDefinitionNode):
             return definition
@@ -21,9 +21,9 @@ def get_first_operation(
 
 
 def get_operation_type(
-    graphql_document: DocumentNode, operation_name: Optional[str] = None
+    graphql_document: DocumentNode, operation_name: str | None = None
 ) -> OperationType:
-    definition: Optional[OperationDefinitionNode] = None
+    definition: OperationDefinitionNode | None = None
 
     if operation_name is not None:
         for d in graphql_document.definitions: