strawberry-graphql 0.255.0__py3-none-any.whl → 0.256.1__py3-none-any.whl

strawberry/extensions/query_depth_limiter.py

@@ -30,12 +30,9 @@ from __future__ import annotations
 import re
 from dataclasses import dataclass
 from typing import (
+    TYPE_CHECKING,
     Callable,
-    Dict,
-    Iterable,
-    List,
     Optional,
-    Type,
     Union,
 )
 
@@ -61,12 +58,15 @@ from graphql.validation import ValidationContext, ValidationRule
 from strawberry.extensions import AddValidationRules
 from strawberry.extensions.utils import is_introspection_key
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
 IgnoreType = Union[Callable[[str], bool], re.Pattern, str]
 
 FieldArgumentType = Union[
-    bool, int, float, str, List["FieldArgumentType"], Dict[str, "FieldArgumentType"]
+    bool, int, float, str, list["FieldArgumentType"], dict[str, "FieldArgumentType"]
 ]
-FieldArgumentsType = Dict[str, FieldArgumentType]
+FieldArgumentsType = dict[str, FieldArgumentType]
 
 
 @dataclass
@@ -99,7 +99,7 @@ class QueryDepthLimiter(AddValidationRules):
     def __init__(
         self,
         max_depth: int,
-        callback: Optional[Callable[[Dict[str, int]], None]] = None,
+        callback: Optional[Callable[[dict[str, int]], None]] = None,
         should_ignore: Optional[ShouldIgnoreType] = None,
     ) -> None:
         """Initialize the QueryDepthLimiter.
@@ -123,8 +123,8 @@ class QueryDepthLimiter(AddValidationRules):
 def create_validator(
     max_depth: int,
     should_ignore: Optional[ShouldIgnoreType],
-    callback: Optional[Callable[[Dict[str, int]], None]] = None,
-) -> Type[ValidationRule]:
+    callback: Optional[Callable[[dict[str, int]], None]] = None,
+) -> type[ValidationRule]:
     class DepthLimitValidator(ValidationRule):
         def __init__(self, validation_context: ValidationContext) -> None:
             document = validation_context.document
@@ -154,7 +154,7 @@ def create_validator(
 
 def get_fragments(
     definitions: Iterable[DefinitionNode],
-) -> Dict[str, FragmentDefinitionNode]:
+) -> dict[str, FragmentDefinitionNode]:
     fragments = {}
     for definition in definitions:
         if isinstance(definition, FragmentDefinitionNode):
@@ -167,7 +167,7 @@ def get_fragments(
 # We can basically treat those the same
 def get_queries_and_mutations(
     definitions: Iterable[DefinitionNode],
-) -> Dict[str, OperationDefinitionNode]:
+) -> dict[str, OperationDefinitionNode]:
     operations = {}
 
     for definition in definitions:
@@ -214,7 +214,7 @@ def get_field_arguments(
 
 def determine_depth(
     node: Node,
-    fragments: Dict[str, FragmentDefinitionNode],
+    fragments: dict[str, FragmentDefinitionNode],
     depth_so_far: int,
     max_depth: int,
     context: ValidationContext,
@@ -294,7 +294,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: Optional[list[IgnoreType]] = 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, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 from strawberry.extensions.context import (
     ExecutingContextManager,
@@ -18,12 +18,12 @@ if TYPE_CHECKING:
 
 
 class SchemaExtensionsRunner:
-    extensions: List[SchemaExtension]
+    extensions: list[SchemaExtension]
 
     def __init__(
         self,
         execution_context: ExecutionContext,
-        extensions: Optional[List[SchemaExtension]] = None,
+        extensions: Optional[list[SchemaExtension]] = None,
     ) -> None:
         self.execution_context = execution_context
         self.extensions = extensions or []
@@ -40,8 +40,8 @@ class SchemaExtensionsRunner:
     def executing(self) -> ExecutingContextManager:
         return ExecutingContextManager(self.extensions)
 
-    def get_extensions_results_sync(self) -> Dict[str, Any]:
-        data: Dict[str, Any] = {}
+    def get_extensions_results_sync(self) -> dict[str, Any]:
+        data: dict[str, Any] = {}
         for extension in self.extensions:
             if inspect.iscoroutinefunction(extension.get_results):
                 msg = "Cannot use async extension hook during sync execution"
@@ -50,8 +50,8 @@ class SchemaExtensionsRunner:
 
         return data
 
-    async def get_extensions_results(self, ctx: ExecutionContext) -> Dict[str, Any]:
-        data: Dict[str, Any] = {}
+    async def get_extensions_results(self, ctx: ExecutionContext) -> dict[str, Any]:
+        data: dict[str, Any] = {}
 
         for extension in self.extensions:
             data.update(await await_maybe(extension.get_results()))

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, Dict, Generator, List, Optional
+from typing import TYPE_CHECKING, Any, Callable, Optional
 
 from strawberry.extensions import SchemaExtension
 from strawberry.extensions.utils import get_path_from_info
@@ -12,6 +12,8 @@ from strawberry.extensions.utils import get_path_from_info
 from .utils import should_skip_tracing
 
 if TYPE_CHECKING:
+    from collections.abc import Generator
+
     from graphql import GraphQLResolveInfo
 
 DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
@@ -25,20 +27,20 @@ class ApolloStepStats:
     start_offset: int
     duration: int
 
-    def to_json(self) -> Dict[str, Any]:
+    def to_json(self) -> dict[str, Any]:
         return {"startOffset": self.start_offset, "duration": self.duration}
 
 
 @dataclasses.dataclass
 class ApolloResolverStats:
-    path: List[str]
+    path: list[str]
     parent_type: Any
     field_name: str
     return_type: Any
     start_offset: int
     duration: Optional[int] = None
 
-    def to_json(self) -> Dict[str, Any]:
+    def to_json(self) -> dict[str, Any]:
         return {
             "path": self.path,
             "field_name": self.field_name,
@@ -51,9 +53,9 @@ class ApolloResolverStats:
 
 @dataclasses.dataclass
 class ApolloExecutionStats:
-    resolvers: List[ApolloResolverStats]
+    resolvers: list[ApolloResolverStats]
 
-    def to_json(self) -> Dict[str, Any]:
+    def to_json(self) -> dict[str, Any]:
         return {"resolvers": [resolver.to_json() for resolver in self.resolvers]}
 
 
@@ -67,7 +69,7 @@ class ApolloTracingStats:
     parsing: ApolloStepStats
     version: int = 1
 
-    def to_json(self) -> Dict[str, Any]:
+    def to_json(self) -> dict[str, Any]:
         return {
             "version": self.version,
             "startTime": self.start_time.strftime(DATETIME_FORMAT),
@@ -81,7 +83,7 @@ class ApolloTracingStats:
 
 class ApolloTracingExtension(SchemaExtension):
     def __init__(self, execution_context: ExecutionContext) -> None:
-        self._resolver_stats: List[ApolloResolverStats] = []
+        self._resolver_stats: list[ApolloResolverStats] = []
         self.execution_context = execution_context
 
     def on_operation(self) -> Generator[None, None, None]:
@@ -121,7 +123,7 @@ class ApolloTracingExtension(SchemaExtension):
             ),
         )
 
-    def get_results(self) -> Dict[str, Dict[str, Any]]:
+    def get_results(self) -> dict[str, dict[str, Any]]:
         return {"tracing": self.stats.to_json()}
 
     async def resolve(

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, Generator, Iterator, Optional
+from typing import TYPE_CHECKING, Any, Callable, Optional
 
 from ddtrace import Span, tracer
 
@@ -11,6 +11,8 @@ from strawberry.extensions import LifecycleStep, SchemaExtension
 from strawberry.extensions.tracing.utils import should_skip_tracing
 
 if TYPE_CHECKING:
+    from collections.abc import Generator, Iterator
+
     from graphql import GraphQLResolveInfo
 
     from strawberry.types.execution import ExecutionContext

strawberry/extensions/tracing/opentelemetry.py

@@ -6,12 +6,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    Dict,
-    FrozenSet,
-    Generator,
-    Iterable,
     Optional,
-    Set,
     Union,
 )
 
@@ -24,6 +19,8 @@ from strawberry.extensions.utils import get_path_from_info
 from .utils import should_skip_tracing
 
 if TYPE_CHECKING:
+    from collections.abc import Generator, Iterable
+
     from graphql import GraphQLResolveInfo
     from opentelemetry.trace import Span, Tracer
 
@@ -32,12 +29,12 @@ if TYPE_CHECKING:
 
 DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
 
-ArgFilter = Callable[[Dict[str, Any], "GraphQLResolveInfo"], Dict[str, Any]]
+ArgFilter = Callable[[dict[str, Any], "GraphQLResolveInfo"], dict[str, Any]]
 
 
 class OpenTelemetryExtension(SchemaExtension):
     _arg_filter: Optional[ArgFilter]
-    _span_holder: Dict[LifecycleStep, Span]
+    _span_holder: dict[LifecycleStep, Span]
     _tracer: Tracer
 
     def __init__(
@@ -100,8 +97,8 @@ class OpenTelemetryExtension(SchemaExtension):
         self._span_holder[LifecycleStep.PARSE].end()
 
     def filter_resolver_args(
-        self, args: Dict[str, Any], info: GraphQLResolveInfo
-    ) -> Dict[str, Any]:
+        self, args: dict[str, Any], info: GraphQLResolveInfo
+    ) -> dict[str, Any]:
         if not self._arg_filter:
             return args
         return self._arg_filter(deepcopy(args), info)
@@ -132,7 +129,7 @@ class OpenTelemetryExtension(SchemaExtension):
         else:
             return str(value)
 
-    def convert_set_to_allowed_types(self, value: Union[Set, FrozenSet]) -> str:
+    def convert_set_to_allowed_types(self, value: Union[set, frozenset]) -> str:
         return (
             "{" + ", ".join(str(self.convert_to_allowed_types(x)) for x in value) + "}"
         )

strawberry/extensions/utils.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, List, Union
+from typing import TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -26,7 +26,7 @@ def is_introspection_field(info: GraphQLResolveInfo) -> bool:
     return False
 
 
-def get_path_from_info(info: GraphQLResolveInfo) -> List[str]:
+def get_path_from_info(info: GraphQLResolveInfo) -> list[str]:
     path = info.path
     elements = []
 
@@ -37,4 +37,4 @@ def get_path_from_info(info: GraphQLResolveInfo) -> List[str]:
     return elements[::-1]
 
 
-__all__ = ["is_introspection_key", "is_introspection_field", "get_path_from_info"]
+__all__ = ["get_path_from_info", "is_introspection_field", "is_introspection_key"]

strawberry/extensions/validation_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 validate_document

strawberry/fastapi/context.py

@@ -1,13 +1,13 @@
-from typing import Any, Dict, Optional, Union
+from typing import Any, Optional, Union
 
 from starlette.background import BackgroundTasks
 from starlette.requests import Request
 from starlette.responses import Response
 from starlette.websockets import WebSocket
 
-CustomContext = Union["BaseContext", Dict[str, Any]]
+CustomContext = Union["BaseContext", dict[str, Any]]
 MergedContext = Union[
-    "BaseContext", Dict[str, Union[Any, BackgroundTasks, Request, Response, WebSocket]]
+    "BaseContext", dict[str, Union[Any, BackgroundTasks, Request, Response, WebSocket]]
 ]
 
 

strawberry/fastapi/router.py

@@ -6,21 +6,15 @@ from inspect import signature
 from typing import (
     TYPE_CHECKING,
     Any,
-    AsyncIterator,
-    Awaitable,
     Callable,
-    Dict,
-    List,
     Optional,
-    Sequence,
-    Type,
     Union,
     cast,
 )
 from typing_extensions import TypeGuard
 
 from starlette import status
-from starlette.background import BackgroundTasks  # noqa: TCH002
+from starlette.background import BackgroundTasks  # noqa: TC002
 from starlette.requests import HTTPConnection, Request
 from starlette.responses import (
     HTMLResponse,
@@ -44,6 +38,7 @@ from strawberry.http.typevars import Context, RootValue
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
 
 if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Awaitable, Sequence
     from enum import Enum
 
     from starlette.routing import BaseRoute
@@ -138,16 +133,16 @@ class GraphQLRouter(
         ),
         connection_init_wait_timeout: timedelta = timedelta(minutes=1),
         prefix: str = "",
-        tags: Optional[List[Union[str, Enum]]] = None,
+        tags: Optional[list[Union[str, Enum]]] = None,
         dependencies: Optional[Sequence[params.Depends]] = None,
-        default_response_class: Type[Response] = Default(JSONResponse),
-        responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
-        callbacks: Optional[List[BaseRoute]] = None,
-        routes: Optional[List[BaseRoute]] = None,
+        default_response_class: type[Response] = Default(JSONResponse),
+        responses: Optional[dict[Union[int, str], dict[str, Any]]] = None,
+        callbacks: Optional[list[BaseRoute]] = None,
+        routes: Optional[list[BaseRoute]] = None,
         redirect_slashes: bool = True,
         default: Optional[ASGIApp] = None,
         dependency_overrides_provider: Optional[Any] = None,
-        route_class: Type[APIRoute] = APIRoute,
+        route_class: type[APIRoute] = APIRoute,
         on_startup: Optional[Sequence[Callable[[], Any]]] = None,
         on_shutdown: Optional[Sequence[Callable[[], Any]]] = None,
         lifespan: Optional[Lifespan[Any]] = None,
@@ -297,7 +292,7 @@ class GraphQLRouter(
         request: Request,
         stream: Callable[[], AsyncIterator[str]],
         sub_response: Response,
-        headers: Dict[str, str],
+        headers: dict[str, str],
     ) -> Response:
         return StreamingResponse(
             stream(),

strawberry/federation/__init__.py

@@ -2,24 +2,24 @@ from .argument import argument
 from .enum import enum, enum_value
 from .field import field
 from .mutation import mutation
-from .object_type import input, interface, interface_object, type
+from .object_type import input, interface, interface_object, type  # noqa: A004
 from .scalar import scalar
 from .schema import Schema
 from .schema_directive import schema_directive
 from .union import union
 
 __all__ = [
+    "Schema",
     "argument",
     "enum",
     "enum_value",
     "field",
-    "mutation",
     "input",
     "interface",
     "interface_object",
-    "type",
+    "mutation",
     "scalar",
-    "Schema",
     "schema_directive",
+    "type",
     "union",
 ]

strawberry/federation/argument.py

@@ -1,4 +1,5 @@
-from typing import Iterable, Optional
+from collections.abc import Iterable
+from typing import Optional
 
 from strawberry.types.arguments import StrawberryArgumentAnnotation
 

strawberry/federation/enum.py

@@ -4,8 +4,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    Iterable,
-    List,
     Optional,
     Union,
     overload,
@@ -15,6 +13,8 @@ from strawberry.types.enum import _process_enum
 from strawberry.types.enum import enum_value as base_enum_value
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable
+
     from strawberry.enum import EnumType, EnumValueDefinition
 
 
@@ -47,8 +47,8 @@ def enum(
     directives: Iterable[object] = (),
     authenticated: bool = False,
     inaccessible: bool = False,
-    policy: Optional[List[List[str]]] = None,
-    requires_scopes: Optional[List[List[str]]] = None,
+    policy: Optional[list[list[str]]] = None,
+    requires_scopes: Optional[list[list[str]]] = None,
     tags: Optional[Iterable[str]] = (),
 ) -> EnumType: ...
 
@@ -62,8 +62,8 @@ def enum(
     directives: Iterable[object] = (),
     authenticated: bool = False,
     inaccessible: bool = False,
-    policy: Optional[List[List[str]]] = None,
-    requires_scopes: Optional[List[List[str]]] = None,
+    policy: Optional[list[list[str]]] = None,
+    requires_scopes: Optional[list[list[str]]] = None,
     tags: Optional[Iterable[str]] = (),
 ) -> Callable[[EnumType], EnumType]: ...
 
@@ -76,8 +76,8 @@ def enum(
     directives=(),
     authenticated: bool = False,
     inaccessible: bool = False,
-    policy: Optional[List[List[str]]] = None,
-    requires_scopes: Optional[List[List[str]]] = None,
+    policy: Optional[list[list[str]]] = None,
+    requires_scopes: Optional[list[list[str]]] = None,
     tags: Optional[Iterable[str]] = (),
 ) -> Union[EnumType, Callable[[EnumType], EnumType]]:
     """Registers the enum in the GraphQL type system.

strawberry/federation/field.py

@@ -5,11 +5,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    Iterable,
-    List,
     Optional,
-    Sequence,
-    Type,
     TypeVar,
     Union,
     overload,
@@ -19,6 +15,7 @@ from strawberry.types.field import field as base_field
 from strawberry.types.unset import UNSET
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable, Sequence
     from typing_extensions import Literal
 
     from strawberry.extensions.field_extension import FieldExtension
@@ -40,20 +37,20 @@ def field(
     authenticated: bool = False,
     external: bool = False,
     inaccessible: bool = False,
-    policy: Optional[List[List[str]]] = None,
-    provides: Optional[List[str]] = None,
+    policy: Optional[list[list[str]]] = None,
+    provides: Optional[list[str]] = None,
     override: Optional[Union[Override, str]] = None,
-    requires: Optional[List[str]] = None,
-    requires_scopes: Optional[List[List[str]]] = None,
+    requires: Optional[list[str]] = None,
+    requires_scopes: Optional[list[list[str]]] = None,
     tags: Optional[Iterable[str]] = (),
     shareable: bool = False,
     init: Literal[False] = False,
-    permission_classes: Optional[List[Type[BasePermission]]] = None,
+    permission_classes: Optional[list[type[BasePermission]]] = None,
     deprecation_reason: Optional[str] = None,
     default: Any = UNSET,
     default_factory: Union[Callable[..., object], object] = UNSET,
     directives: Sequence[object] = (),
-    extensions: Optional[List[FieldExtension]] = None,
+    extensions: Optional[list[FieldExtension]] = None,
     graphql_type: Optional[Any] = None,
 ) -> T: ...
 
@@ -67,20 +64,20 @@ def field(
     authenticated: bool = False,
     external: bool = False,
     inaccessible: bool = False,
-    policy: Optional[List[List[str]]] = None,
-    provides: Optional[List[str]] = None,
+    policy: Optional[list[list[str]]] = None,
+    provides: Optional[list[str]] = None,
     override: Optional[Union[Override, str]] = None,
-    requires: Optional[List[str]] = None,
-    requires_scopes: Optional[List[List[str]]] = None,
+    requires: Optional[list[str]] = None,
+    requires_scopes: Optional[list[list[str]]] = None,
     tags: Optional[Iterable[str]] = (),
     shareable: bool = False,
     init: Literal[True] = True,
-    permission_classes: Optional[List[Type[BasePermission]]] = None,
+    permission_classes: Optional[list[type[BasePermission]]] = None,
     deprecation_reason: Optional[str] = None,
     default: Any = UNSET,
     default_factory: Union[Callable[..., object], object] = UNSET,
     directives: Sequence[object] = (),
-    extensions: Optional[List[FieldExtension]] = None,
+    extensions: Optional[list[FieldExtension]] = None,
     graphql_type: Optional[Any] = None,
 ) -> Any: ...
 
@@ -95,19 +92,19 @@ def field(
     authenticated: bool = False,
     external: bool = False,
     inaccessible: bool = False,
-    policy: Optional[List[List[str]]] = None,
-    provides: Optional[List[str]] = None,
+    policy: Optional[list[list[str]]] = None,
+    provides: Optional[list[str]] = None,
     override: Optional[Union[Override, str]] = None,
-    requires: Optional[List[str]] = None,
-    requires_scopes: Optional[List[List[str]]] = None,
+    requires: Optional[list[str]] = None,
+    requires_scopes: Optional[list[list[str]]] = None,
     tags: Optional[Iterable[str]] = (),
     shareable: bool = False,
-    permission_classes: Optional[List[Type[BasePermission]]] = None,
+    permission_classes: Optional[list[type[BasePermission]]] = None,
     deprecation_reason: Optional[str] = None,
     default: Any = UNSET,
     default_factory: Union[Callable[..., object], object] = UNSET,
     directives: Sequence[object] = (),
-    extensions: Optional[List[FieldExtension]] = None,
+    extensions: Optional[list[FieldExtension]] = None,
     graphql_type: Optional[Any] = None,
 ) -> StrawberryField: ...
 
@@ -121,19 +118,19 @@ def field(
     authenticated: bool = False,
     external: bool = False,
     inaccessible: bool = False,
-    policy: Optional[List[List[str]]] = None,
-    provides: Optional[List[str]] = None,
+    policy: Optional[list[list[str]]] = None,
+    provides: Optional[list[str]] = None,
     override: Optional[Union[Override, str]] = None,
-    requires: Optional[List[str]] = None,
-    requires_scopes: Optional[List[List[str]]] = None,
+    requires: Optional[list[str]] = None,
+    requires_scopes: Optional[list[list[str]]] = None,
     tags: Optional[Iterable[str]] = (),
     shareable: bool = False,
-    permission_classes: Optional[List[Type[BasePermission]]] = None,
+    permission_classes: Optional[list[type[BasePermission]]] = None,
     deprecation_reason: Optional[str] = None,
     default: Any = dataclasses.MISSING,
     default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
     directives: Sequence[object] = (),
-    extensions: Optional[List[FieldExtension]] = None,
+    extensions: Optional[list[FieldExtension]] = None,
     graphql_type: Optional[Any] = 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