strawberry-graphql 0.254.1__py3-none-any.whl → 0.256.0__py3-none-any.whl

strawberry/experimental/pydantic/exceptions.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, List, Type
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from pydantic import BaseModel
@@ -8,7 +8,7 @@ if TYPE_CHECKING:
 
 
 class MissingFieldsListError(Exception):
-    def __init__(self, type: Type[BaseModel]) -> None:
+    def __init__(self, type: type[BaseModel]) -> None:
         message = (
             f"List of fields to copy from {type} is empty. Add fields with the "
             f"`auto` type annotation"
@@ -22,7 +22,7 @@ class UnsupportedTypeError(Exception):
 
 
 class UnregisteredTypeException(Exception):
-    def __init__(self, type: Type[BaseModel]) -> None:
+    def __init__(self, type: type[BaseModel]) -> None:
         message = (
             f"Cannot find a Strawberry Type for {type} did you forget to register it?"
         )
@@ -43,9 +43,9 @@ class BothDefaultAndDefaultFactoryDefinedError(Exception):
 class AutoFieldsNotInBaseModelError(Exception):
     def __init__(
         self,
-        fields: List[str],
+        fields: list[str],
         cls_name: str,
-        model: Type[BaseModel],
+        model: type[BaseModel],
     ) -> None:
         message = (
             f"{cls_name} defines {fields} with strawberry.auto. "

strawberry/experimental/pydantic/fields.py

@@ -1,6 +1,5 @@
 import builtins
-from typing import Any, Union
-from typing_extensions import Annotated
+from typing import Annotated, Any, Union
 
 from pydantic import BaseModel
 
@@ -25,17 +24,7 @@ except ImportError:
     else:
         raise
 
-try:
-    from typing import GenericAlias as TypingGenericAlias  # type: ignore
-except ImportError:
-    import sys
-
-    # python < 3.9 does not have GenericAlias (list[int], tuple[str, ...] and so on)
-    # we do this under a conditional to avoid a mypy :)
-    if sys.version_info < (3, 9):
-        TypingGenericAlias = ()
-    else:
-        raise
+from typing import GenericAlias as TypingGenericAlias  # type: ignore
 
 
 def replace_pydantic_types(type_: Any, is_input: bool) -> Any:

strawberry/experimental/pydantic/object_type.py

@@ -7,12 +7,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    Dict,
-    List,
     Optional,
-    Sequence,
-    Set,
-    Type,
     cast,
 )
 
@@ -39,6 +34,9 @@ from strawberry.types.object_type import _process_type, _wrap_dataclass
 from strawberry.types.type_resolver import _get_fields
 
 if TYPE_CHECKING:
+    import builtins
+    from collections.abc import Sequence
+
     from graphql import GraphQLResolveInfo
 
 
@@ -59,8 +57,8 @@ def get_type_for_field(field: CompatModelField, is_input: bool, compat: Pydantic
 def _build_dataclass_creation_fields(
     field: CompatModelField,
     is_input: bool,
-    existing_fields: Dict[str, StrawberryField],
-    auto_fields_set: Set[str],
+    existing_fields: dict[str, StrawberryField],
+    auto_fields_set: set[str],
     use_pydantic_alias: bool,
     compat: PydanticCompat,
 ) -> DataclassCreationFields:
@@ -118,9 +116,9 @@ if TYPE_CHECKING:
 
 
 def type(
-    model: Type[PydanticModel],
+    model: builtins.type[PydanticModel],
     *,
-    fields: Optional[List[str]] = None,
+    fields: Optional[list[str]] = None,
     name: Optional[str] = None,
     is_input: bool = False,
     is_interface: bool = False,
@@ -128,8 +126,8 @@ def type(
     directives: Optional[Sequence[object]] = (),
     all_fields: bool = False,
     use_pydantic_alias: bool = True,
-) -> Callable[..., Type[StrawberryTypeFromPydantic[PydanticModel]]]:
-    def wrap(cls: Any) -> Type[StrawberryTypeFromPydantic[PydanticModel]]:
+) -> Callable[..., builtins.type[StrawberryTypeFromPydantic[PydanticModel]]]:
+    def wrap(cls: Any) -> builtins.type[StrawberryTypeFromPydantic[PydanticModel]]:
         compat = PydanticCompat.from_model(model)
         model_fields = compat.get_model_fields(model)
         original_fields_set = set(fields) if fields else set()
@@ -177,12 +175,12 @@ def type(
 
         wrapped = _wrap_dataclass(cls)
         extra_strawberry_fields = _get_fields(wrapped, {})
-        extra_fields = cast(List[dataclasses.Field], extra_strawberry_fields)
+        extra_fields = cast(list[dataclasses.Field], extra_strawberry_fields)
         private_fields = get_private_fields(wrapped)
 
         extra_fields_dict = {field.name: field for field in extra_strawberry_fields}
 
-        all_model_fields: List[DataclassCreationFields] = [
+        all_model_fields: list[DataclassCreationFields] = [
             _build_dataclass_creation_fields(
                 field,
                 is_input,
@@ -208,7 +206,7 @@ def type(
         # Implicitly define `is_type_of` to support interfaces/unions that use
         # pydantic objects (not the corresponding strawberry type)
         @classmethod  # type: ignore
-        def is_type_of(cls: Type, obj: Any, _info: GraphQLResolveInfo) -> bool:
+        def is_type_of(cls: builtins.type, obj: Any, _info: GraphQLResolveInfo) -> bool:
             return isinstance(obj, (cls, model))
 
         namespace = {"is_type_of": is_type_of}
@@ -232,7 +230,7 @@ def type(
         if hasattr(cls, "resolve_reference"):
             namespace["resolve_reference"] = cls.resolve_reference
 
-        kwargs: Dict[str, object] = {}
+        kwargs: dict[str, object] = {}
 
         # Python 3.10.1 introduces the kw_only param to `make_dataclass`.
         # If we're on an older version then generate our own custom init function
@@ -273,7 +271,7 @@ def type(
         cls._pydantic_type = model
 
         def from_pydantic_default(
-            instance: PydanticModel, extra: Optional[Dict[str, Any]] = None
+            instance: PydanticModel, extra: Optional[dict[str, Any]] = None
         ) -> StrawberryTypeFromPydantic[PydanticModel]:
             ret = convert_pydantic_model_to_strawberry_class(
                 cls=cls, model_instance=instance, extra=extra
@@ -302,16 +300,16 @@ def type(
 
 
 def input(
-    model: Type[PydanticModel],
+    model: builtins.type[PydanticModel],
     *,
-    fields: Optional[List[str]] = None,
+    fields: Optional[list[str]] = None,
     name: Optional[str] = None,
     is_interface: bool = False,
     description: Optional[str] = None,
     directives: Optional[Sequence[object]] = (),
     all_fields: bool = False,
     use_pydantic_alias: bool = True,
-) -> Callable[..., Type[StrawberryTypeFromPydantic[PydanticModel]]]:
+) -> Callable[..., builtins.type[StrawberryTypeFromPydantic[PydanticModel]]]:
     """Convenience decorator for creating an input type from a Pydantic model.
 
     Equal to `partial(type, is_input=True)`
@@ -332,16 +330,16 @@ def input(
 
 
 def interface(
-    model: Type[PydanticModel],
+    model: builtins.type[PydanticModel],
     *,
-    fields: Optional[List[str]] = None,
+    fields: Optional[list[str]] = None,
     name: Optional[str] = None,
     is_input: bool = False,
     description: Optional[str] = None,
     directives: Optional[Sequence[object]] = (),
     all_fields: bool = False,
     use_pydantic_alias: bool = True,
-) -> Callable[..., Type[StrawberryTypeFromPydantic[PydanticModel]]]:
+) -> Callable[..., builtins.type[StrawberryTypeFromPydantic[PydanticModel]]]:
     """Convenience decorator for creating an interface type from a Pydantic model.
 
     Equal to `partial(type, is_interface=True)`

strawberry/experimental/pydantic/utils.py

@@ -4,11 +4,7 @@ import dataclasses
 from typing import (
     TYPE_CHECKING,
     Any,
-    List,
     NamedTuple,
-    Set,
-    Tuple,
-    Type,
     Union,
     cast,
 )
@@ -38,9 +34,9 @@ if TYPE_CHECKING:
     from pydantic.typing import NoArgAnyCallable
 
 
-def normalize_type(type_: Type) -> Any:
+def normalize_type(type_: type) -> Any:
     if is_list(type_):
-        return List[normalize_type(get_list_annotation(type_))]  # type: ignore
+        return list[normalize_type(get_list_annotation(type_))]  # type: ignore
 
     if is_optional(type_):
         return get_optional_annotation(type_)
@@ -55,7 +51,7 @@ def get_strawberry_type_from_model(type_: Any) -> Any:
         raise UnregisteredTypeException(type_)
 
 
-def get_private_fields(cls: Type) -> List[dataclasses.Field]:
+def get_private_fields(cls: type) -> list[dataclasses.Field]:
     return [field for field in dataclasses.fields(cls) if is_private(field.type)]
 
 
@@ -63,10 +59,10 @@ class DataclassCreationFields(NamedTuple):
     """Fields required for the fields parameter of make_dataclass."""
 
     name: str
-    field_type: Type
+    field_type: type
     field: dataclasses.Field
 
-    def to_tuple(self) -> Tuple[str, Type, dataclasses.Field]:
+    def to_tuple(self) -> tuple[str, type, dataclasses.Field]:
         # fields parameter wants (name, type, Field)
         return self.name, self.field_type, self.field
 
@@ -125,7 +121,7 @@ def get_default_factory_for_field(
 
 
 def ensure_all_auto_fields_in_pydantic(
-    model: Type[BaseModel], auto_fields: Set[str], cls_name: str
+    model: type[BaseModel], auto_fields: set[str], cls_name: str
 ) -> None:
     compat = PydanticCompat.from_model(model)
     # Raise error if user defined a strawberry.auto field not present in the model

strawberry/ext/dataclasses/dataclasses.py

@@ -11,15 +11,15 @@ from dataclasses import (  # type: ignore
     _field_init,
     _init_param,
 )
-from typing import Any, Dict, List
+from typing import Any
 
 
 def dataclass_init_fn(
-    fields: List[Any],
+    fields: list[Any],
     frozen: bool,
     has_post_init: bool,
     self_name: str,
-    globals_: Dict[str, Any],
+    globals_: dict[str, Any],
 ) -> Any:
     """Create an __init__ function for a dataclass.
 

strawberry/ext/mypy_plugin.py

@@ -8,10 +8,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    List,
     Optional,
-    Set,
-    Tuple,
     Union,
     cast,
 )
@@ -60,7 +57,7 @@ try:
 except ImportError:
     TypeVarDef = TypeVarType
 
-PYDANTIC_VERSION: Optional[Tuple[int, ...]] = None
+PYDANTIC_VERSION: Optional[tuple[int, ...]] = None
 
 # To be compatible with user who don't use pydantic
 try:
@@ -326,7 +323,7 @@ def add_static_method_to_class(
     api: Union[SemanticAnalyzerPluginInterface, CheckerPluginInterface],
     cls: ClassDef,
     name: str,
-    args: List[Argument],
+    args: list[Argument],
     return_type: Type,
     tvar_def: Optional[TypeVarType] = None,
 ) -> None:
@@ -410,7 +407,7 @@ def strawberry_pydantic_class_callback(ctx: ClassDefContext) -> None:
         model_type = cast(Instance, _get_type_for_expr(model_expression, ctx.api))
 
         # these are the fields that the user added to the strawberry type
-        new_strawberry_fields: Set[str] = set()
+        new_strawberry_fields: set[str] = set()
 
         # TODO: think about inheritance for strawberry?
         for stmt in ctx.cls.defs.body:
@@ -418,7 +415,7 @@ def strawberry_pydantic_class_callback(ctx: ClassDefContext) -> None:
                 lhs = cast(NameExpr, stmt.lvalues[0])
                 new_strawberry_fields.add(lhs.name)
 
-        pydantic_fields: Set[PydanticModelField] = set()
+        pydantic_fields: set[PydanticModelField] = set()
         try:
             fields = model_type.type.metadata[PYDANTIC_METADATA_KEY]["fields"]
             for data in fields.items():
@@ -438,7 +435,7 @@ def strawberry_pydantic_class_callback(ctx: ClassDefContext) -> None:
                 ctx.reason,
             )
 
-        potentially_missing_fields: Set[PydanticModelField] = {
+        potentially_missing_fields: set[PydanticModelField] = {
             f for f in pydantic_fields if f.name not in new_strawberry_fields
         }
 
@@ -449,7 +446,7 @@ def strawberry_pydantic_class_callback(ctx: ClassDefContext) -> None:
         This means that the user is using all_fields=True
         """
         is_all_fields: bool = len(potentially_missing_fields) == len(pydantic_fields)
-        missing_pydantic_fields: Set[PydanticModelField] = (
+        missing_pydantic_fields: set[PydanticModelField] = (
             potentially_missing_fields if not is_all_fields else set()
         )
 

strawberry/extensions/__init__.py

@@ -1,5 +1,4 @@
 import warnings
-from typing import Type
 
 from .add_validation_rules import AddValidationRules
 from .base_extension import LifecycleStep, SchemaExtension
@@ -13,7 +12,7 @@ from .query_depth_limiter import IgnoreContext, QueryDepthLimiter
 from .validation_cache import ValidationCache
 
 
-def __getattr__(name: str) -> Type[SchemaExtension]:
+def __getattr__(name: str) -> type[SchemaExtension]:
     if name == "Extension":
         warnings.warn(
             (
@@ -29,16 +28,16 @@ def __getattr__(name: str) -> Type[SchemaExtension]:
 
 
 __all__ = [
-    "FieldExtension",
-    "SchemaExtension",
-    "LifecycleStep",
     "AddValidationRules",
     "DisableValidation",
-    "ParserCache",
-    "QueryDepthLimiter",
+    "FieldExtension",
     "IgnoreContext",
-    "ValidationCache",
+    "LifecycleStep",
     "MaskErrors",
     "MaxAliasesLimiter",
     "MaxTokensLimiter",
+    "ParserCache",
+    "QueryDepthLimiter",
+    "SchemaExtension",
+    "ValidationCache",
 ]

strawberry/extensions/add_validation_rules.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Iterator, List, Type
+from typing import TYPE_CHECKING
 
 from strawberry.extensions.base_extension import SchemaExtension
 
 if TYPE_CHECKING:
+    from collections.abc import Iterator
+
     from graphql import ASTValidationRule
 
 
@@ -37,9 +39,9 @@ class AddValidationRules(SchemaExtension):
     ```
     """
 
-    validation_rules: List[Type[ASTValidationRule]]
+    validation_rules: list[type[ASTValidationRule]]
 
-    def __init__(self, validation_rules: List[Type[ASTValidationRule]]) -> None:
+    def __init__(self, validation_rules: list[type[ASTValidationRule]]) -> None:
         self.validation_rules = validation_rules
 
     def on_operation(self) -> Iterator[None]:

strawberry/extensions/base_extension.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Callable, Dict, Set
+from typing import TYPE_CHECKING, Any, Callable
 
 from strawberry.utils.await_maybe import AsyncIteratorOrIterator, AwaitableOrValue
 
@@ -60,7 +60,7 @@ class SchemaExtension:
     ) -> AwaitableOrValue[object]:
         return _next(root, info, *args, **kwargs)
 
-    def get_results(self) -> AwaitableOrValue[Dict[str, Any]]:
+    def get_results(self) -> AwaitableOrValue[dict[str, Any]]:
         return {}
 
     @classmethod
@@ -71,11 +71,11 @@ class SchemaExtension:
 
 Hook = Callable[[SchemaExtension], AsyncIteratorOrIterator[None]]
 
-HOOK_METHODS: Set[str] = {
+HOOK_METHODS: set[str] = {
     SchemaExtension.on_operation.__name__,
     SchemaExtension.on_validate.__name__,
     SchemaExtension.on_parse.__name__,
     SchemaExtension.on_execute.__name__,
 }
 
-__all__ = ["SchemaExtension", "Hook", "HOOK_METHODS", "LifecycleStep"]
+__all__ = ["HOOK_METHODS", "Hook", "LifecycleStep", "SchemaExtension"]

strawberry/extensions/context.py

@@ -8,15 +8,9 @@ from asyncio import iscoroutinefunction
 from typing import (
     TYPE_CHECKING,
     Any,
-    AsyncContextManager,
-    AsyncIterator,
     Callable,
-    ContextManager,
-    Iterator,
-    List,
     NamedTuple,
     Optional,
-    Type,
     Union,
 )
 
@@ -24,6 +18,7 @@ from strawberry.extensions import SchemaExtension
 from strawberry.utils.await_maybe import AwaitableOrValue, await_maybe
 
 if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Iterator
     from types import TracebackType
 
     from strawberry.extensions.base_extension import Hook
@@ -31,17 +26,23 @@ if TYPE_CHECKING:
 
 class WrappedHook(NamedTuple):
     extension: SchemaExtension
-    hook: Callable[..., Union[AsyncContextManager[None], ContextManager[None]]]
+    hook: Callable[
+        ...,
+        Union[
+            contextlib.AbstractAsyncContextManager[None],
+            contextlib.AbstractContextManager[None],
+        ],
+    ]
     is_async: bool
 
 
 class ExtensionContextManagerBase:
     __slots__ = (
-        "hooks",
-        "deprecation_message",
-        "default_hook",
         "async_exit_stack",
+        "default_hook",
+        "deprecation_message",
         "exit_stack",
+        "hooks",
     )
 
     def __init_subclass__(cls) -> None:
@@ -56,8 +57,8 @@ class ExtensionContextManagerBase:
     LEGACY_ENTER: str
     LEGACY_EXIT: str
 
-    def __init__(self, extensions: List[SchemaExtension]) -> None:
-        self.hooks: List[WrappedHook] = []
+    def __init__(self, extensions: list[SchemaExtension]) -> None:
+        self.hooks: list[WrappedHook] = []
         self.default_hook: Hook = getattr(SchemaExtension, self.HOOK_NAME)
         for extension in extensions:
             hook = self.get_hook(extension)
@@ -179,7 +180,7 @@ class ExtensionContextManagerBase:
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
+        exc_type: Optional[type[BaseException]],
         exc_val: Optional[BaseException],
         exc_tb: Optional[TracebackType],
     ) -> None:
@@ -198,7 +199,7 @@ class ExtensionContextManagerBase:
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
+        exc_type: Optional[type[BaseException]],
         exc_val: Optional[BaseException],
         exc_tb: Optional[TracebackType],
     ) -> None:

strawberry/extensions/directives.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Callable, Dict, Tuple
+from typing import TYPE_CHECKING, Any, Callable
 
 from strawberry.extensions import SchemaExtension
 from strawberry.types.nodes import convert_arguments
@@ -62,7 +62,7 @@ def process_directive(
     directive: DirectiveNode,
     value: Any,
     info: GraphQLResolveInfo,
-) -> Tuple[StrawberryDirective, Dict[str, Any]]:
+) -> tuple[StrawberryDirective, dict[str, Any]]:
     """Get a `StrawberryDirective` from ``directive` and prepare its arguments."""
     directive_name = directive.name.value
     schema: Schema = info.schema._strawberry_schema  # type: ignore

strawberry/extensions/disable_validation.py

@@ -1,4 +1,4 @@
-from typing import Iterator
+from collections.abc import Iterator
 
 from strawberry.extensions.base_extension import SchemaExtension
 

strawberry/extensions/field_extension.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import itertools
+from collections.abc import Awaitable
 from functools import cached_property
-from typing import TYPE_CHECKING, Any, Awaitable, Callable, Union
+from typing import TYPE_CHECKING, Any, Callable, Union
 
 if TYPE_CHECKING:
     from typing_extensions import TypeAlias

strawberry/extensions/mask_errors.py

@@ -1,4 +1,5 @@
-from typing import Callable, Iterator, List
+from collections.abc import Iterator
+from typing import Callable
 
 from graphql.error import GraphQLError
 
@@ -36,7 +37,7 @@ class MaskErrors(SchemaExtension):
         yield
         result = self.execution_context.result
         if result and result.errors:
-            processed_errors: List[GraphQLError] = []
+            processed_errors: list[GraphQLError] = []
             for error in result.errors:
                 if self.should_mask_error(error):
                     processed_errors.append(self.anonymise_error(error))

strawberry/extensions/max_aliases.py

@@ -1,4 +1,4 @@
-from typing import Type, Union
+from typing import Union
 
 from graphql import (
     ExecutableDefinitionNode,
@@ -35,7 +35,7 @@ class MaxAliasesLimiter(AddValidationRules):
         super().__init__([validator])
 
 
-def create_validator(max_alias_count: int) -> Type[ValidationRule]:
+def create_validator(max_alias_count: int) -> type[ValidationRule]:
     """Create a validator that checks the number of aliases in a document.
 
     Args:

strawberry/extensions/max_tokens.py

@@ -1,4 +1,4 @@
-from typing import Iterator
+from collections.abc import Iterator
 
 from strawberry.extensions.base_extension import SchemaExtension
 

strawberry/extensions/parser_cache.py

@@ -1,5 +1,6 @@
+from collections.abc import Iterator
 from functools import lru_cache
-from typing import Iterator, Optional
+from typing import Optional
 
 from strawberry.extensions.base_extension import SchemaExtension
 from strawberry.schema.execute import parse_document

strawberry/extensions/pyinstrument.py

@@ -1,12 +1,15 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Iterator
+from typing import TYPE_CHECKING
 
 from pyinstrument import Profiler
 
 from strawberry.extensions.base_extension import SchemaExtension
 
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
 
 class PyInstrument(SchemaExtension):
     """Extension to profile the execution time of resolvers using PyInstrument."""