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

strawberry/experimental/pydantic/object_type.py

@@ -6,7 +6,6 @@ import warnings
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     Optional,
     cast,
 )
@@ -36,7 +35,7 @@ from strawberry.types.type_resolver import _get_fields
 
 if TYPE_CHECKING:
     import builtins
-    from collections.abc import Sequence
+    from collections.abc import Callable, Sequence
 
     from graphql import GraphQLResolveInfo
 
@@ -50,7 +49,7 @@ def get_type_for_field(field: CompatModelField, is_input: bool, compat: Pydantic
         # only pydantic v1 has this Optional logic
         should_add_optional: bool = field.allow_none
         if should_add_optional:
-            return Optional[replaced_type]
+            return Optional[replaced_type]  # noqa: UP045
 
     return replaced_type
 
@@ -116,20 +115,20 @@ if TYPE_CHECKING:
     )
 
 
-def type(  # noqa: PLR0915
+def type(
     model: builtins.type[PydanticModel],
     *,
-    fields: Optional[list[str]] = None,
-    name: Optional[str] = None,
+    fields: list[str] | None = 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 = (),
     all_fields: bool = False,
     include_computed: bool = False,
     use_pydantic_alias: bool = True,
 ) -> Callable[..., builtins.type[StrawberryTypeFromPydantic[PydanticModel]]]:
-    def wrap(cls: Any) -> builtins.type[StrawberryTypeFromPydantic[PydanticModel]]:  # noqa: PLR0915
+    def wrap(cls: Any) -> builtins.type[StrawberryTypeFromPydantic[PydanticModel]]:
         compat = PydanticCompat.from_model(model)
         model_fields = compat.get_model_fields(model, include_computed=include_computed)
         original_fields_set = set(fields) if fields else set()
@@ -247,8 +246,6 @@ def type(  # noqa: PLR0915
         # https://github.com/python/cpython/issues/89961
         if sys.version_info >= (3, 10, 1):
             kwargs["kw_only"] = dataclasses.MISSING
-        else:
-            kwargs["init"] = False
 
         cls = dataclasses.make_dataclass(
             cls.__name__,
@@ -258,11 +255,6 @@ def type(  # noqa: PLR0915
             **kwargs,  # type: ignore
         )
 
-        if sys.version_info < (3, 10, 1):
-            from strawberry.utils.dataclasses import add_custom_init_fn
-
-            add_custom_init_fn(cls)
-
         _process_type(
             cls,
             name=name,
@@ -279,7 +271,7 @@ def type(  # noqa: PLR0915
         cls._pydantic_type = model
 
         def from_pydantic_default(
-            instance: PydanticModel, extra: Optional[dict[str, Any]] = None
+            instance: PydanticModel, extra: dict[str, Any] | None = None
         ) -> StrawberryTypeFromPydantic[PydanticModel]:
             ret = convert_pydantic_model_to_strawberry_class(
                 cls=cls, model_instance=instance, extra=extra
@@ -310,11 +302,11 @@ def type(  # noqa: PLR0915
 def input(
     model: builtins.type[PydanticModel],
     *,
-    fields: Optional[list[str]] = None,
-    name: Optional[str] = None,
+    fields: list[str] | None = None,
+    name: str | None = None,
     is_interface: bool = False,
-    description: Optional[str] = None,
-    directives: Optional[Sequence[object]] = (),
+    description: str | None = None,
+    directives: Sequence[object] | None = (),
     all_fields: bool = False,
     use_pydantic_alias: bool = True,
 ) -> Callable[..., builtins.type[StrawberryTypeFromPydantic[PydanticModel]]]:
@@ -340,11 +332,11 @@ def input(
 def interface(
     model: builtins.type[PydanticModel],
     *,
-    fields: Optional[list[str]] = None,
-    name: Optional[str] = None,
+    fields: list[str] | None = None,
+    name: str | None = None,
     is_input: bool = False,
-    description: Optional[str] = None,
-    directives: Optional[Sequence[object]] = (),
+    description: str | None = None,
+    directives: Sequence[object] | None = (),
     all_fields: bool = False,
     use_pydantic_alias: bool = True,
 ) -> Callable[..., builtins.type[StrawberryTypeFromPydantic[PydanticModel]]]:

strawberry/experimental/pydantic/utils.py

@@ -5,7 +5,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     NamedTuple,
-    Union,
     cast,
 )
 
@@ -69,7 +68,7 @@ class DataclassCreationFields(NamedTuple):
 def get_default_factory_for_field(
     field: CompatModelField,
     compat: PydanticCompat,
-) -> Union[NoArgAnyCallable, dataclasses._MISSING_TYPE]:
+) -> NoArgAnyCallable | dataclasses._MISSING_TYPE:
     """Gets the default factory for a pydantic field.
 
     Handles mutable defaults when making the dataclass by

strawberry/ext/mypy_plugin.py

@@ -1,15 +1,11 @@
 from __future__ import annotations
 
 import re
-import typing
 import warnings
 from decimal import Decimal
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Optional,
-    Union,
     cast,
 )
 
@@ -57,7 +53,7 @@ try:
 except ImportError:
     TypeVarDef = TypeVarType
 
-PYDANTIC_VERSION: Optional[tuple[int, ...]] = None
+PYDANTIC_VERSION: tuple[int, ...] | None = None
 
 # To be compatible with user who don't use pydantic
 try:
@@ -74,6 +70,8 @@ except ImportError:
 
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from mypy.nodes import ClassDef, Expression
     from mypy.plugins import (  # type: ignore
         AnalyzeTypeContext,
@@ -241,7 +239,7 @@ def enum_hook(ctx: DynamicClassDefContext) -> None:
             )
             return
 
-    enum_type: Optional[Type]
+    enum_type: Type | None
 
     try:
         enum_type = _get_type_for_expr(first_argument, ctx.api)
@@ -289,7 +287,7 @@ def scalar_hook(ctx: DynamicClassDefContext) -> None:
             )
             return
 
-    scalar_type: Optional[Type]
+    scalar_type: Type | None
 
     # TODO: add proper support for NewType
 
@@ -314,12 +312,12 @@ def scalar_hook(ctx: DynamicClassDefContext) -> None:
 
 
 def add_static_method_to_class(
-    api: Union[SemanticAnalyzerPluginInterface, CheckerPluginInterface],
+    api: SemanticAnalyzerPluginInterface | CheckerPluginInterface,
     cls: ClassDef,
     name: str,
     args: list[Argument],
     return_type: Type,
-    tvar_def: Optional[TypeVarType] = None,
+    tvar_def: TypeVarType | None = None,
 ) -> None:
     """Adds a static method.
 
@@ -355,7 +353,7 @@ def add_static_method_to_class(
         arg_types, arg_kinds, arg_names, return_type, function_type
     )
     if tvar_def:
-        signature.variables = [tvar_def]
+        signature.variables = [tvar_def]  # type: ignore[assignment]
 
     func = FuncDef(name, args, Block([PassStmt()]))
 
@@ -527,7 +525,7 @@ def strawberry_pydantic_class_callback(ctx: ClassDefContext) -> None:
 class StrawberryPlugin(Plugin):
     def get_dynamic_class_hook(
         self, fullname: str
-    ) -> Optional[Callable[[DynamicClassDefContext], None]]:
+    ) -> Callable[[DynamicClassDefContext], None] | None:
         # TODO: investigate why we need this instead of `strawberry.union.union` on CI
         # we have the same issue in the other hooks
         if self._is_strawberry_union(fullname):
@@ -544,7 +542,7 @@ class StrawberryPlugin(Plugin):
 
         return None
 
-    def get_type_analyze_hook(self, fullname: str) -> Union[Callable[..., Type], None]:
+    def get_type_analyze_hook(self, fullname: str) -> Callable[..., Type] | None:
         if self._is_strawberry_lazy_type(fullname):
             return lazy_type_analyze_callback
 
@@ -552,7 +550,7 @@ class StrawberryPlugin(Plugin):
 
     def get_class_decorator_hook(
         self, fullname: str
-    ) -> Optional[Callable[[ClassDefContext], None]]:
+    ) -> Callable[[ClassDefContext], None] | None:
         if self._is_strawberry_pydantic_decorator(fullname):
             return strawberry_pydantic_class_callback
 
@@ -613,7 +611,7 @@ class StrawberryPlugin(Plugin):
         )
 
 
-def plugin(version: str) -> typing.Type[StrawberryPlugin]:
+def plugin(version: str) -> type[StrawberryPlugin]:
     match = VERSION_RE.match(version)
     if match:
         MypyVersion.VERSION = Decimal(".".join(match.groups()))

strawberry/extensions/base_extension.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
 from strawberry.utils.await_maybe import AsyncIteratorOrIterator, AwaitableOrValue
 

strawberry/extensions/context.py

@@ -8,17 +8,14 @@ from asyncio import iscoroutinefunction
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     NamedTuple,
-    Optional,
-    Union,
 )
 
 from strawberry.extensions import SchemaExtension
 from strawberry.utils.await_maybe import AwaitableOrValue, await_maybe
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncIterator, Iterator
+    from collections.abc import AsyncIterator, Callable, Iterator
     from types import TracebackType
 
     from strawberry.extensions.base_extension import Hook
@@ -28,10 +25,8 @@ class WrappedHook(NamedTuple):
     extension: SchemaExtension
     hook: Callable[
         ...,
-        Union[
-            contextlib.AbstractAsyncContextManager[None],
-            contextlib.AbstractContextManager[None],
-        ],
+        contextlib.AbstractAsyncContextManager[None]
+        | contextlib.AbstractContextManager[None],
     ]
     is_async: bool
 
@@ -65,12 +60,12 @@ class ExtensionContextManagerBase:
             if hook:
                 self.hooks.append(hook)
 
-    def get_hook(self, extension: SchemaExtension) -> Optional[WrappedHook]:
+    def get_hook(self, extension: SchemaExtension) -> WrappedHook | None:
         on_start = getattr(extension, self.LEGACY_ENTER, None)
         on_end = getattr(extension, self.LEGACY_EXIT, None)
 
         is_legacy = on_start is not None or on_end is not None
-        hook_fn: Optional[Hook] = getattr(type(extension), self.HOOK_NAME)
+        hook_fn: Hook | None = getattr(type(extension), self.HOOK_NAME)
         hook_fn = hook_fn if hook_fn is not self.default_hook else None
         if is_legacy and hook_fn is not None:
             raise ValueError(
@@ -111,8 +106,8 @@ class ExtensionContextManagerBase:
     @staticmethod
     def from_legacy(
         extension: SchemaExtension,
-        on_start: Optional[Callable[[], None]] = None,
-        on_end: Optional[Callable[[], None]] = None,
+        on_start: Callable[[], None] | None = None,
+        on_end: Callable[[], None] | None = None,
     ) -> WrappedHook:
         if iscoroutinefunction(on_start) or iscoroutinefunction(on_end):
 
@@ -176,9 +171,9 @@ class ExtensionContextManagerBase:
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         self.exit_stack.__exit__(exc_type, exc_val, exc_tb)
 
@@ -195,9 +190,9 @@ class ExtensionContextManagerBase:
 
     async def __aexit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         await self.async_exit_stack.__aexit__(exc_type, exc_val, exc_tb)
 

strawberry/extensions/directives.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
 from strawberry.extensions import SchemaExtension
 from strawberry.types.nodes import convert_arguments
 from strawberry.utils.await_maybe import await_maybe
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from graphql import DirectiveNode, GraphQLResolveInfo
 
     from strawberry.directive import StrawberryDirective
@@ -29,7 +31,9 @@ class DirectivesExtension(SchemaExtension):
     ) -> AwaitableOrValue[Any]:
         value = await await_maybe(_next(root, info, *args, **kwargs))
 
-        for directive in info.field_nodes[0].directives:
+        nodes = list(info.field_nodes)
+
+        for directive in nodes[0].directives:
             if directive.name.value in SPECIFIED_DIRECTIVES:
                 continue
             strawberry_directive, arguments = process_directive(directive, value, info)
@@ -49,7 +53,9 @@ class DirectivesExtensionSync(SchemaExtension):
     ) -> AwaitableOrValue[Any]:
         value = _next(root, info, *args, **kwargs)
 
-        for directive in info.field_nodes[0].directives:
+        nodes = list(info.field_nodes)
+
+        for directive in nodes[0].directives:
             if directive.name.value in SPECIFIED_DIRECTIVES:
                 continue
             strawberry_directive, arguments = process_directive(directive, value, info)

strawberry/extensions/field_extension.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
 import itertools
-from collections.abc import Awaitable
+from collections.abc import Awaitable, Callable
 from functools import cached_property
-from typing import TYPE_CHECKING, Any, Callable, Union
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from typing_extensions import TypeAlias
+    from typing import TypeAlias
 
     from strawberry.types import Info
     from strawberry.types.field import StrawberryField
@@ -69,7 +69,7 @@ def _get_async_resolvers(
 
 def build_field_extension_resolvers(
     field: StrawberryField,
-) -> list[Union[SyncExtensionResolver, AsyncExtensionResolver]]:
+) -> list[SyncExtensionResolver | AsyncExtensionResolver]:
     """Builds a list of resolvers for a field with extensions.
 
     Verifies that all of the field extensions for a given field support

strawberry/extensions/mask_errors.py

@@ -1,9 +1,11 @@
-from collections.abc import Iterator
-from typing import Callable
+from collections.abc import Callable, Iterator
+from typing import Any
 
 from graphql.error import GraphQLError
+from graphql.execution.execute import ExecutionResult as GraphQLExecutionResult
 
 from strawberry.extensions.base_extension import SchemaExtension
+from strawberry.types.execution import ExecutionResult as StrawberryExecutionResult
 
 
 def default_should_mask_error(_: GraphQLError) -> bool:
@@ -33,18 +35,27 @@ class MaskErrors(SchemaExtension):
             original_error=None,
         )
 
+    # TODO: proper typing
+    def _process_result(self, result: Any) -> None:
+        if not result.errors:
+            return
+
+        processed_errors: list[GraphQLError] = []
+
+        for error in result.errors:
+            if self.should_mask_error(error):
+                processed_errors.append(self.anonymise_error(error))
+            else:
+                processed_errors.append(error)
+
+        result.errors = processed_errors
+
     def on_operation(self) -> Iterator[None]:
         yield
-        result = self.execution_context.result
-        if result and result.errors:
-            processed_errors: list[GraphQLError] = []
-            for error in result.errors:
-                if self.should_mask_error(error):
-                    processed_errors.append(self.anonymise_error(error))
-                else:
-                    processed_errors.append(error)
-
-            result.errors = processed_errors
 
+        result = self.execution_context.result
 
-__all__ = ["MaskErrors"]
+        if isinstance(result, (GraphQLExecutionResult, StrawberryExecutionResult)):
+            self._process_result(result)
+        elif result:
+            self._process_result(result.initial_result)

strawberry/extensions/max_aliases.py

@@ -1,5 +1,3 @@
-from typing import Union
-
 from graphql import (
     ExecutableDefinitionNode,
     FieldNode,
@@ -64,7 +62,7 @@ def create_validator(max_alias_count: int) -> type[ValidationRule]:
 
 
 def count_fields_with_alias(
-    selection_set_owner: Union[ExecutableDefinitionNode, FieldNode, InlineFragmentNode],
+    selection_set_owner: ExecutableDefinitionNode | FieldNode | InlineFragmentNode,
 ) -> int:
     if selection_set_owner.selection_set is None:
         return 0

strawberry/extensions/parser_cache.py

@@ -1,6 +1,5 @@
 from collections.abc import Iterator
 from functools import lru_cache
-from typing import Optional
 
 from graphql.language.parser import parse
 
@@ -25,7 +24,7 @@ class ParserCache(SchemaExtension):
     ```
     """
 
-    def __init__(self, maxsize: Optional[int] = None) -> None:
+    def __init__(self, maxsize: int | None = None) -> None:
         """Initialize the ParserCache.
 
         Args:

strawberry/extensions/query_depth_limiter.py

@@ -28,12 +28,11 @@
 from __future__ import annotations
 
 import re
+from collections.abc import Callable
 from dataclasses import dataclass
 from typing import (
     TYPE_CHECKING,
-    Callable,
-    Optional,
-    Union,
+    TypeAlias,
 )
 
 from graphql import GraphQLError
@@ -61,12 +60,17 @@ from strawberry.extensions.utils import is_introspection_key
 if TYPE_CHECKING:
     from collections.abc import Iterable
 
-IgnoreType = Union[Callable[[str], bool], re.Pattern, str]
+IgnoreType: TypeAlias = Callable[[str], bool] | re.Pattern | str
 
-FieldArgumentType = Union[
-    bool, int, float, str, list["FieldArgumentType"], dict[str, "FieldArgumentType"]
-]
-FieldArgumentsType = dict[str, FieldArgumentType]
+FieldArgumentType: TypeAlias = (
+    bool
+    | int
+    | float
+    | str
+    | list["FieldArgumentType"]
+    | dict[str, "FieldArgumentType"]
+)
+FieldArgumentsType: TypeAlias = dict[str, FieldArgumentType]
 
 
 @dataclass
@@ -99,8 +103,8 @@ class QueryDepthLimiter(AddValidationRules):
     def __init__(
         self,
         max_depth: int,
-        callback: Optional[Callable[[dict[str, int]], None]] = None,
-        should_ignore: Optional[ShouldIgnoreType] = None,
+        callback: Callable[[dict[str, int]], None] | None = None,
+        should_ignore: ShouldIgnoreType | None = None,
     ) -> None:
         """Initialize the QueryDepthLimiter.
 
@@ -122,8 +126,8 @@ class QueryDepthLimiter(AddValidationRules):
 
 def create_validator(
     max_depth: int,
-    should_ignore: Optional[ShouldIgnoreType],
-    callback: Optional[Callable[[dict[str, int]], None]] = None,
+    should_ignore: ShouldIgnoreType | None,
+    callback: Callable[[dict[str, int]], None] | None = None,
 ) -> type[ValidationRule]:
     class DepthLimitValidator(ValidationRule):
         def __init__(self, validation_context: ValidationContext) -> None:
@@ -218,7 +222,7 @@ def determine_depth(
     max_depth: int,
     context: ValidationContext,
     operation_name: str,
-    should_ignore: Optional[ShouldIgnoreType],
+    should_ignore: ShouldIgnoreType | None,
 ) -> int:
     if depth_so_far > max_depth:
         context.report_error(
@@ -288,7 +292,7 @@ def determine_depth(
     raise TypeError(f"Depth crawler cannot handle: {node.kind}")  # pragma: no cover
 
 
-def is_ignored(node: FieldNode, ignore: Optional[list[IgnoreType]] = None) -> bool:
+def is_ignored(node: FieldNode, ignore: list[IgnoreType] | None = None) -> bool:
     if ignore is None:
         return False
 

strawberry/extensions/runner.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import inspect
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from strawberry.extensions.context import (
     ExecutingContextManager,
@@ -23,7 +23,7 @@ class SchemaExtensionsRunner:
     def __init__(
         self,
         execution_context: ExecutionContext,
-        extensions: Optional[list[SchemaExtension]] = None,
+        extensions: list[SchemaExtension] | None = None,
     ) -> None:
         self.execution_context = execution_context
         self.extensions = extensions or []

strawberry/extensions/tracing/apollo.py

@@ -4,7 +4,7 @@ import dataclasses
 import time
 from datetime import datetime, timezone
 from inspect import isawaitable
-from typing import TYPE_CHECKING, Any, Callable, Optional
+from typing import TYPE_CHECKING, Any
 
 from strawberry.extensions import SchemaExtension
 from strawberry.extensions.utils import get_path_from_info
@@ -12,7 +12,7 @@ from strawberry.extensions.utils import get_path_from_info
 from .utils import should_skip_tracing
 
 if TYPE_CHECKING:
-    from collections.abc import Generator
+    from collections.abc import Callable, Generator
 
     from graphql import GraphQLResolveInfo
 
@@ -38,7 +38,7 @@ class ApolloResolverStats:
     field_name: str
     return_type: Any
     start_offset: int
-    duration: Optional[int] = None
+    duration: int | None = None
 
     def to_json(self) -> dict[str, Any]:
         return {

strawberry/extensions/tracing/datadog.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import hashlib
 from functools import cached_property
 from inspect import isawaitable
-from typing import TYPE_CHECKING, Any, Callable, Optional
+from typing import TYPE_CHECKING, Any
 
 import ddtrace
 from packaging import version
@@ -19,7 +19,7 @@ else:
 
 
 if TYPE_CHECKING:
-    from collections.abc import Generator, Iterator
+    from collections.abc import Callable, Generator, Iterator
 
     from graphql import GraphQLResolveInfo
 
@@ -30,7 +30,7 @@ class DatadogTracingExtension(SchemaExtension):
     def __init__(
         self,
         *,
-        execution_context: Optional[ExecutionContext] = None,
+        execution_context: ExecutionContext | None = None,
     ) -> None:
         if execution_context:
             self.execution_context = execution_context

strawberry/extensions/tracing/opentelemetry.py

@@ -1,13 +1,11 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from copy import deepcopy
 from inspect import isawaitable
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Optional,
-    Union,
 )
 
 from opentelemetry import trace
@@ -33,16 +31,16 @@ ArgFilter = Callable[[dict[str, Any], "GraphQLResolveInfo"], dict[str, Any]]
 
 
 class OpenTelemetryExtension(SchemaExtension):
-    _arg_filter: Optional[ArgFilter]
+    _arg_filter: ArgFilter | None
     _span_holder: dict[LifecycleStep, Span]
     _tracer: Tracer
 
     def __init__(
         self,
         *,
-        execution_context: Optional[ExecutionContext] = None,
-        arg_filter: Optional[ArgFilter] = None,
-        tracer_provider: Optional[trace.TracerProvider] = None,
+        execution_context: ExecutionContext | None = None,
+        arg_filter: ArgFilter | None = None,
+        tracer_provider: trace.TracerProvider | None = None,
     ) -> None:
         self._arg_filter = arg_filter
         self._tracer = trace.get_tracer("strawberry", tracer_provider=tracer_provider)
@@ -129,7 +127,7 @@ class OpenTelemetryExtension(SchemaExtension):
             return bytes(value)  # Convert bytearray and memoryview to bytes
         return str(value)
 
-    def convert_set_to_allowed_types(self, value: Union[set, frozenset]) -> str:
+    def convert_set_to_allowed_types(self, value: set | frozenset) -> str:
         return (
             "{" + ", ".join(str(self.convert_to_allowed_types(x)) for x in value) + "}"
         )