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

strawberry/django/views.py

@@ -5,10 +5,7 @@ import warnings
 from typing import (
     TYPE_CHECKING,
     Any,
-    AsyncIterator,
     Callable,
-    Dict,
-    Mapping,
     Optional,
     Union,
     cast,
@@ -42,6 +39,8 @@ from strawberry.http.typevars import (
 from .context import StrawberryDjangoContext
 
 if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Mapping
+
     from django.template.response import TemplateResponse
 
     from strawberry.http import GraphQLHTTPResponse
@@ -190,7 +189,7 @@ class BaseView:
         request: HttpRequest,
         stream: Callable[[], AsyncIterator[Any]],
         sub_response: TemporalHttpResponse,
-        headers: Dict[str, str],
+        headers: dict[str, str],
     ) -> HttpResponseBase:
         return StreamingHttpResponse(
             streaming_content=stream(),
@@ -318,4 +317,4 @@ class AsyncGraphQLView(
         raise NotImplementedError
 
 
-__all__ = ["GraphQLView", "AsyncGraphQLView"]
+__all__ = ["AsyncGraphQLView", "GraphQLView"]

strawberry/exceptions/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from functools import cached_property
-from typing import TYPE_CHECKING, Dict, Optional, Set, Union
+from typing import TYPE_CHECKING, Optional, Union
 
 from graphql import GraphQLError
 
@@ -48,7 +48,7 @@ class UnallowedReturnTypeForUnion(Exception):
     """The return type is not in the list of Union types."""
 
     def __init__(
-        self, field_name: str, result_type: str, allowed_types: Set[GraphQLObjectType]
+        self, field_name: str, result_type: str, allowed_types: set[GraphQLObjectType]
     ) -> None:
         formatted_allowed_types = list(sorted(type_.name for type_ in allowed_types))
 
@@ -160,37 +160,37 @@ class StrawberryGraphQLError(GraphQLError):
 class ConnectionRejectionError(Exception):
     """Use it when you want to reject a WebSocket connection."""
 
-    def __init__(self, payload: Dict[str, object] = {}) -> None:
+    def __init__(self, payload: dict[str, object] = {}) -> None:
         self.payload = payload
 
 
 __all__ = [
-    "StrawberryException",
-    "UnableToFindExceptionSource",
+    "ConflictingArgumentsError",
+    "DuplicatedTypeName",
+    "FieldWithResolverAndDefaultFactoryError",
+    "FieldWithResolverAndDefaultValueError",
+    "InvalidArgumentTypeError",
+    "InvalidCustomContext",
+    "InvalidDefaultFactoryError",
+    "InvalidTypeForUnionMergeError",
+    "InvalidUnionTypeError",
     "MissingArgumentsAnnotationsError",
+    "MissingFieldAnnotationError",
+    "MissingOptionalDependenciesError",
+    "MissingQueryError",
     "MissingReturnAnnotationError",
-    "WrongReturnTypeForUnion",
-    "UnallowedReturnTypeForUnion",
+    "MissingTypesForGenericError",
+    "MultipleStrawberryArgumentsError",
     "ObjectIsNotAnEnumError",
     "ObjectIsNotClassError",
-    "InvalidUnionTypeError",
-    "InvalidTypeForUnionMergeError",
-    "MissingTypesForGenericError",
-    "UnsupportedTypeError",
-    "UnresolvedFieldTypeError",
     "PrivateStrawberryFieldError",
-    "MultipleStrawberryArgumentsError",
     "ScalarAlreadyRegisteredError",
-    "WrongNumberOfResultsReturned",
-    "FieldWithResolverAndDefaultValueError",
-    "FieldWithResolverAndDefaultFactoryError",
-    "ConflictingArgumentsError",
-    "MissingQueryError",
-    "InvalidArgumentTypeError",
-    "InvalidDefaultFactoryError",
-    "InvalidCustomContext",
-    "MissingFieldAnnotationError",
-    "DuplicatedTypeName",
+    "StrawberryException",
     "StrawberryGraphQLError",
-    "MissingOptionalDependenciesError",
+    "UnableToFindExceptionSource",
+    "UnallowedReturnTypeForUnion",
+    "UnresolvedFieldTypeError",
+    "UnsupportedTypeError",
+    "WrongNumberOfResultsReturned",
+    "WrongReturnTypeForUnion",
 ]

strawberry/exceptions/conflicting_arguments.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from functools import cached_property
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, Optional
 
 from .exception import StrawberryException
 from .utils.source_finder import SourceFinder
@@ -16,7 +16,7 @@ class ConflictingArgumentsError(StrawberryException):
     def __init__(
         self,
         resolver: StrawberryResolver,
-        arguments: List[str],
+        arguments: list[str],
     ) -> None:
         self.function = resolver.wrapped_func
         self.argument_names = arguments

strawberry/exceptions/duplicated_type_name.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from functools import cached_property
-from typing import TYPE_CHECKING, Optional, Type
+from typing import TYPE_CHECKING, Optional
 
 from .exception import StrawberryException
 from .utils.source_finder import SourceFinder
@@ -17,8 +17,8 @@ class DuplicatedTypeName(StrawberryException):
 
     def __init__(
         self,
-        first_cls: Optional[Type],
-        second_cls: Optional[Type],
+        first_cls: Optional[type],
+        second_cls: Optional[type],
         duplicated_type_name: str,
     ) -> None:
         self.first_cls = first_cls

strawberry/exceptions/handler.py

@@ -2,7 +2,7 @@ import os
 import sys
 import threading
 from types import TracebackType
-from typing import Any, Callable, Optional, Tuple, Type, cast
+from typing import Any, Callable, Optional, cast
 
 from .exception import StrawberryException, UnableToFindExceptionSource
 
@@ -10,7 +10,7 @@ original_threading_exception_hook = threading.excepthook
 
 
 ExceptionHandler = Callable[
-    [Type[BaseException], BaseException, Optional[TracebackType]], None
+    [type[BaseException], BaseException, Optional[TracebackType]], None
 ]
 
 
@@ -20,7 +20,7 @@ def should_use_rich_exceptions() -> bool:
     return errors_disabled.lower() not in ["true", "1", "yes"]
 
 
-def _get_handler(exception_type: Type[BaseException]) -> ExceptionHandler:
+def _get_handler(exception_type: type[BaseException]) -> ExceptionHandler:
     if issubclass(exception_type, StrawberryException):
         try:
             import rich
@@ -29,7 +29,7 @@ def _get_handler(exception_type: Type[BaseException]) -> ExceptionHandler:
         else:
 
             def _handler(
-                exception_type: Type[BaseException],
+                exception_type: type[BaseException],
                 exception: BaseException,
                 traceback: Optional[TracebackType],
             ) -> None:
@@ -47,7 +47,7 @@ def _get_handler(exception_type: Type[BaseException]) -> ExceptionHandler:
 
 
 def strawberry_exception_handler(
-    exception_type: Type[BaseException],
+    exception_type: type[BaseException],
     exception: BaseException,
     traceback: Optional[TracebackType],
 ) -> None:
@@ -55,8 +55,8 @@ def strawberry_exception_handler(
 
 
 def strawberry_threading_exception_handler(
-    args: Tuple[
-        Type[BaseException],
+    args: tuple[
+        type[BaseException],
         Optional[BaseException],
         Optional[TracebackType],
         Optional[threading.Thread],

strawberry/exceptions/invalid_union_type.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from functools import cached_property
 from inspect import getframeinfo, stack
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional, Type
+from typing import TYPE_CHECKING, Optional
 
 from strawberry.exceptions.utils.source_finder import SourceFinder
 
@@ -80,7 +80,7 @@ class InvalidUnionTypeError(StrawberryException):
 class InvalidTypeForUnionMergeError(StrawberryException):
     """A specialized version of InvalidUnionTypeError for when trying to merge unions using the pipe operator."""
 
-    invalid_type: Type
+    invalid_type: type
 
     def __init__(self, union: StrawberryUnion, other: object) -> None:
         self.union = union

strawberry/exceptions/missing_arguments_annotations.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from functools import cached_property
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, Optional
 
 from .exception import StrawberryException
 from .utils.source_finder import SourceFinder
@@ -18,7 +18,7 @@ class MissingArgumentsAnnotationsError(StrawberryException):
     def __init__(
         self,
         resolver: StrawberryResolver,
-        arguments: List[str],
+        arguments: list[str],
     ) -> None:
         self.missing_arguments = arguments
         self.function = resolver.wrapped_func

strawberry/exceptions/missing_field_annotation.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from functools import cached_property
-from typing import TYPE_CHECKING, Optional, Type
+from typing import TYPE_CHECKING, Optional
 
 from .exception import StrawberryException
 from .utils.source_finder import SourceFinder
@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 
 
 class MissingFieldAnnotationError(StrawberryException):
-    def __init__(self, field_name: str, cls: Type) -> None:
+    def __init__(self, field_name: str, cls: type) -> None:
         self.cls = cls
         self.field_name = field_name
 

strawberry/exceptions/object_is_not_an_enum.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from functools import cached_property
-from typing import TYPE_CHECKING, Optional, Type
+from typing import TYPE_CHECKING, Optional
 
 from .exception import StrawberryException
 from .utils.source_finder import SourceFinder
@@ -13,7 +13,7 @@ if TYPE_CHECKING:
 
 
 class ObjectIsNotAnEnumError(StrawberryException):
-    def __init__(self, cls: Type[Enum]) -> None:
+    def __init__(self, cls: type[Enum]) -> None:
         self.cls = cls
         self.message = (
             "strawberry.enum can only be used with subclasses of Enum. "

strawberry/exceptions/private_strawberry_field.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from functools import cached_property
-from typing import TYPE_CHECKING, Optional, Type
+from typing import TYPE_CHECKING, Optional
 
 from .exception import StrawberryException
 from .utils.source_finder import SourceFinder
@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 
 
 class PrivateStrawberryFieldError(StrawberryException):
-    def __init__(self, field_name: str, cls: Type) -> None:
+    def __init__(self, field_name: str, cls: type) -> None:
         self.cls = cls
         self.field_name = field_name
 

strawberry/exceptions/syntax.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Dict, Optional, Set, Tuple
+from typing import TYPE_CHECKING, Optional
 
 from pygments.lexers import PythonLexer
 from rich.segment import Segment
@@ -14,10 +14,10 @@ class Syntax(RichSyntax):
     def __init__(
         self,
         code: str,
-        line_range: Tuple[int, int],
-        highlight_lines: Optional[Set[int]] = None,
+        line_range: tuple[int, int],
+        highlight_lines: Optional[set[int]] = None,
         line_offset: int = 0,
-        line_annotations: Optional[Dict[int, str]] = None,
+        line_annotations: Optional[dict[int, str]] = None,
     ) -> None:
         self.line_offset = line_offset
         self.line_annotations = line_annotations or {}

strawberry/exceptions/utils/source_finder.py

@@ -6,11 +6,12 @@ import sys
 from dataclasses import dataclass
 from functools import cached_property
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Optional, Sequence, Type, cast
+from typing import TYPE_CHECKING, Any, Callable, Optional, cast
 
 from ..exception_source import ExceptionSource
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
     from inspect import Traceback
 
     from libcst import BinaryOperation, Call, CSTNode, FunctionDef
@@ -113,7 +114,7 @@ class LibCSTSourceFinder:
         )
 
     def _find_class_definition(
-        self, source: SourcePath, cls: Type[Any]
+        self, source: SourcePath, cls: type[Any]
     ) -> Optional[CSTNode]:
         import libcst.matchers as m
 
@@ -122,7 +123,7 @@ class LibCSTSourceFinder:
         class_defs = self._find(source.code, matcher)
         return self._find_definition_by_qualname(cls.__qualname__, class_defs)
 
-    def find_class(self, cls: Type[Any]) -> Optional[ExceptionSource]:
+    def find_class(self, cls: type[Any]) -> Optional[ExceptionSource]:
         source = self.find_source(cls.__module__)
 
         if source is None:
@@ -147,7 +148,7 @@ class LibCSTSourceFinder:
         )
 
     def find_class_attribute(
-        self, cls: Type[Any], attribute_name: str
+        self, cls: type[Any], attribute_name: str
     ) -> Optional[ExceptionSource]:
         source = self.find_source(cls.__module__)
 
@@ -560,11 +561,11 @@ class SourceFinder:
         except ImportError:
             return None  # pragma: no cover
 
-    def find_class_from_object(self, cls: Type[Any]) -> Optional[ExceptionSource]:
+    def find_class_from_object(self, cls: type[Any]) -> Optional[ExceptionSource]:
         return self.cst.find_class(cls) if self.cst else None
 
     def find_class_attribute_from_object(
-        self, cls: Type[Any], attribute_name: str
+        self, cls: type[Any], attribute_name: str
     ) -> Optional[ExceptionSource]:
         return self.cst.find_class_attribute(cls, attribute_name) if self.cst else None
 

strawberry/experimental/pydantic/__init__.py

@@ -1,11 +1,11 @@
 from .error_type import error_type
 from .exceptions import UnregisteredTypeException
-from .object_type import input, interface, type
+from .object_type import input, interface, type  # noqa: A004
 
 __all__ = [
-    "error_type",
     "UnregisteredTypeException",
+    "error_type",
     "input",
-    "type",
     "interface",
+    "type",
 ]

strawberry/experimental/pydantic/_compat.py

@@ -2,7 +2,7 @@ import dataclasses
 from dataclasses import dataclass
 from decimal import Decimal
 from functools import cached_property
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Type
+from typing import TYPE_CHECKING, Any, Callable, Optional
 from uuid import UUID
 
 import pydantic
@@ -98,7 +98,7 @@ ATTR_TO_TYPE_MAP_Pydantic_Core_V2 = {
 }
 
 
-def get_fields_map_for_v2() -> Dict[Any, Any]:
+def get_fields_map_for_v2() -> dict[Any, Any]:
     import pydantic_core
 
     fields_map = {
@@ -124,7 +124,7 @@ class PydanticV2Compat:
 
         return PydanticUndefined
 
-    def get_model_fields(self, model: Type[BaseModel]) -> Dict[str, CompatModelField]:
+    def get_model_fields(self, model: type[BaseModel]) -> dict[str, CompatModelField]:
         field_info: dict[str, FieldInfo] = model.model_fields
         new_fields = {}
         # Convert it into CompatModelField
@@ -147,10 +147,10 @@ class PydanticV2Compat:
         return new_fields
 
     @cached_property
-    def fields_map(self) -> Dict[Any, Any]:
+    def fields_map(self) -> dict[Any, Any]:
         return get_fields_map_for_v2()
 
-    def get_basic_type(self, type_: Any) -> Type[Any]:
+    def get_basic_type(self, type_: Any) -> type[Any]:
         if type_ in self.fields_map:
             type_ = self.fields_map[type_]
 
@@ -162,7 +162,7 @@ class PydanticV2Compat:
 
         return type_
 
-    def model_dump(self, model_instance: BaseModel) -> Dict[Any, Any]:
+    def model_dump(self, model_instance: BaseModel) -> dict[Any, Any]:
         return model_instance.model_dump()
 
 
@@ -171,7 +171,7 @@ class PydanticV1Compat:
     def PYDANTIC_MISSING_TYPE(self) -> Any:
         return dataclasses.MISSING
 
-    def get_model_fields(self, model: Type[BaseModel]) -> Dict[str, CompatModelField]:
+    def get_model_fields(self, model: type[BaseModel]) -> dict[str, CompatModelField]:
         new_fields = {}
         # Convert it into CompatModelField
         for name, field in model.__fields__.items():  # type: ignore[attr-defined]
@@ -192,7 +192,7 @@ class PydanticV1Compat:
         return new_fields
 
     @cached_property
-    def fields_map(self) -> Dict[Any, Any]:
+    def fields_map(self) -> dict[Any, Any]:
         if IS_PYDANTIC_V2:
             return {
                 getattr(pydantic.v1, field_name): type
@@ -206,7 +206,7 @@ class PydanticV1Compat:
             if hasattr(pydantic, field_name)
         }
 
-    def get_basic_type(self, type_: Any) -> Type[Any]:
+    def get_basic_type(self, type_: Any) -> type[Any]:
         if IS_PYDANTIC_V1:
             ConstrainedInt = pydantic.ConstrainedInt
             ConstrainedFloat = pydantic.ConstrainedFloat
@@ -225,7 +225,7 @@ class PydanticV1Compat:
         if lenient_issubclass(type_, ConstrainedStr):
             return str
         if lenient_issubclass(type_, ConstrainedList):
-            return List[self.get_basic_type(type_.item_type)]  # type: ignore
+            return list[self.get_basic_type(type_.item_type)]  # type: ignore
 
         if type_ in self.fields_map:
             type_ = self.fields_map[type_]
@@ -238,7 +238,7 @@ class PydanticV1Compat:
 
         return type_
 
-    def model_dump(self, model_instance: BaseModel) -> Dict[Any, Any]:
+    def model_dump(self, model_instance: BaseModel) -> dict[Any, Any]:
         return model_instance.dict()
 
 
@@ -250,7 +250,7 @@ class PydanticCompat:
             self._compat = PydanticV1Compat()  # type: ignore[assignment]
 
     @classmethod
-    def from_model(cls, model: Type[BaseModel]) -> "PydanticCompat":
+    def from_model(cls, model: type[BaseModel]) -> "PydanticCompat":
         if hasattr(model, "model_fields"):
             return cls(is_v2=True)
 
@@ -283,10 +283,10 @@ else:
 
 __all__ = [
     "PydanticCompat",
+    "get_args",
+    "get_origin",
     "is_new_type",
     "lenient_issubclass",
-    "get_origin",
-    "get_args",
     "new_type_supertype",
     "smart_deepcopy",
 ]

strawberry/experimental/pydantic/conversion.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import copy
 import dataclasses
-from typing import TYPE_CHECKING, Any, Type, Union, cast
+from typing import TYPE_CHECKING, Any, Union, cast
 
 from strawberry.types.base import (
     StrawberryList,
@@ -98,7 +98,7 @@ def convert_pydantic_model_to_strawberry_class(
     return cls(**kwargs)
 
 
-def convert_strawberry_class_to_pydantic_model(obj: Type) -> Any:
+def convert_strawberry_class_to_pydantic_model(obj: type) -> Any:
     if hasattr(obj, "to_pydantic"):
         return obj.to_pydantic()
     elif dataclasses.is_dataclass(obj):

strawberry/experimental/pydantic/conversion_types.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict, Optional, Type, TypeVar
+from typing import TYPE_CHECKING, Any, Optional, TypeVar
 from typing_extensions import Protocol
 
 from pydantic import BaseModel
@@ -22,7 +22,7 @@ class StrawberryTypeFromPydantic(Protocol[PydanticModel]):
 
     @staticmethod
     def from_pydantic(
-        instance: PydanticModel, extra: Optional[Dict[str, Any]] = None
+        instance: PydanticModel, extra: Optional[dict[str, Any]] = None
     ) -> StrawberryTypeFromPydantic[PydanticModel]: ...
 
     def to_pydantic(self, **kwargs: Any) -> PydanticModel: ...
@@ -31,4 +31,4 @@ class StrawberryTypeFromPydantic(Protocol[PydanticModel]):
     def __strawberry_definition__(self) -> StrawberryObjectDefinition: ...
 
     @property
-    def _pydantic_type(self) -> Type[PydanticModel]: ...
+    def _pydantic_type(self) -> type[PydanticModel]: ...

strawberry/experimental/pydantic/error_type.py

@@ -3,13 +3,10 @@ from __future__ import annotations
 import dataclasses
 import warnings
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
-    List,
     Optional,
-    Sequence,
-    Tuple,
-    Type,
     Union,
     cast,
 )
@@ -33,14 +30,19 @@ from strawberry.utils.typing import get_list_annotation, is_list
 
 from .exceptions import MissingFieldsListError
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
 
-def get_type_for_field(field: CompatModelField) -> Union[Any, Type[None], Type[List]]:
+    from strawberry.types.base import WithStrawberryObjectDefinition
+
+
+def get_type_for_field(field: CompatModelField) -> Union[type[Union[None, list]], Any]:
     type_ = field.outer_type_
     type_ = normalize_type(type_)
     return field_type_to_type(type_)
 
 
-def field_type_to_type(type_: Type) -> Union[Any, List[Any], None]:
+def field_type_to_type(type_: type) -> Union[Any, list[Any], None]:
     error_class: Any = str
     strawberry_type: Any = error_class
 
@@ -52,26 +54,26 @@ def field_type_to_type(type_: Type) -> Union[Any, List[Any], None]:
         elif lenient_issubclass(child_type, BaseModel):
             strawberry_type = get_strawberry_type_from_model(child_type)
         else:
-            strawberry_type = List[error_class]
+            strawberry_type = list[error_class]
 
         strawberry_type = Optional[strawberry_type]
     elif lenient_issubclass(type_, BaseModel):
         strawberry_type = get_strawberry_type_from_model(type_)
         return Optional[strawberry_type]
 
-    return Optional[List[strawberry_type]]
+    return Optional[list[strawberry_type]]
 
 
 def error_type(
-    model: Type[BaseModel],
+    model: type[BaseModel],
     *,
-    fields: Optional[List[str]] = None,
+    fields: Optional[list[str]] = None,
     name: Optional[str] = None,
     description: Optional[str] = None,
     directives: Optional[Sequence[object]] = (),
     all_fields: bool = False,
-) -> Callable[..., Type]:
-    def wrap(cls: Type) -> Type:
+) -> Callable[..., type]:
+    def wrap(cls: type) -> type:
         compat = PydanticCompat.from_model(model)
         model_fields = compat.get_model_fields(model)
         fields_set = set(fields) if fields else set()
@@ -103,7 +105,7 @@ def error_type(
         if not fields_set:
             raise MissingFieldsListError(cls)
 
-        all_model_fields: List[Tuple[str, Any, dataclasses.Field]] = [
+        all_model_fields: list[tuple[str, Any, dataclasses.Field]] = [
             (
                 name,
                 get_type_for_field(field),
@@ -113,8 +115,8 @@ def error_type(
             if name in fields_set
         ]
 
-        wrapped = _wrap_dataclass(cls)
-        extra_fields = cast(List[dataclasses.Field], _get_fields(wrapped, {}))
+        wrapped: type[WithStrawberryObjectDefinition] = _wrap_dataclass(cls)
+        extra_fields = cast(list[dataclasses.Field], _get_fields(wrapped, {}))
         private_fields = get_private_fields(wrapped)
 
         all_model_fields.extend(
@@ -146,7 +148,7 @@ def error_type(
         )
 
         model._strawberry_type = cls  # type: ignore[attr-defined]
-        cls._pydantic_type = model
+        cls._pydantic_type = model  # type: ignore[attr-defined]
         return cls
 
     return wrap