strawberry-graphql 0.224.1__py3-none-any.whl → 0.225.0__py3-none-any.whl

strawberry/extensions/__init__.py

@@ -1,4 +1,5 @@
 import warnings
+from typing import Type
 
 from .add_validation_rules import AddValidationRules
 from .base_extension import LifecycleStep, SchemaExtension
@@ -12,7 +13,7 @@ from .query_depth_limiter import IgnoreContext, QueryDepthLimiter
 from .validation_cache import ValidationCache
 
 
-def __getattr__(name: str):
+def __getattr__(name: str) -> Type[SchemaExtension]:
     if name == "Extension":
         warnings.warn(
             (

strawberry/extensions/add_validation_rules.py

@@ -38,7 +38,7 @@ class AddValidationRules(SchemaExtension):
 
     validation_rules: List[Type[ASTValidationRule]]
 
-    def __init__(self, validation_rules: List[Type[ASTValidationRule]]):
+    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

@@ -21,7 +21,7 @@ class LifecycleStep(Enum):
 class SchemaExtension:
     execution_context: ExecutionContext
 
-    def __init__(self, *, execution_context: ExecutionContext):
+    def __init__(self, *, execution_context: ExecutionContext) -> None:
         self.execution_context = execution_context
 
     def on_operation(

strawberry/extensions/context.py

@@ -2,13 +2,16 @@ from __future__ import annotations
 
 import contextlib
 import inspect
+import types
 import warnings
 from asyncio import iscoroutinefunction
 from typing import (
     TYPE_CHECKING,
     Any,
+    AsyncContextManager,
     AsyncIterator,
     Callable,
+    ContextManager,
     Iterator,
     List,
     NamedTuple,
@@ -28,14 +31,20 @@ if TYPE_CHECKING:
 
 class WrappedHook(NamedTuple):
     extension: SchemaExtension
-    initialized_hook: Union[AsyncIterator[None], Iterator[None]]
+    hook: Callable[..., Union[AsyncContextManager[None], ContextManager[None]]]
     is_async: bool
 
 
 class ExtensionContextManagerBase:
-    __slots__ = ("hooks", "deprecation_message", "default_hook")
-
-    def __init_subclass__(cls):
+    __slots__ = (
+        "hooks",
+        "deprecation_message",
+        "default_hook",
+        "async_exit_stack",
+        "exit_stack",
+    )
+
+    def __init_subclass__(cls) -> None:
         cls.DEPRECATION_MESSAGE = (
             f"Event driven styled extensions for "
             f"{cls.LEGACY_ENTER} or {cls.LEGACY_EXIT}"
@@ -47,7 +56,7 @@ class ExtensionContextManagerBase:
     LEGACY_ENTER: str
     LEGACY_EXIT: str
 
-    def __init__(self, extensions: List[SchemaExtension]):
+    def __init__(self, extensions: List[SchemaExtension]) -> None:
         self.hooks: List[WrappedHook] = []
         self.default_hook: Hook = getattr(SchemaExtension, self.HOOK_NAME)
         for extension in extensions:
@@ -73,10 +82,20 @@ class ExtensionContextManagerBase:
 
         if hook_fn:
             if inspect.isgeneratorfunction(hook_fn):
-                return WrappedHook(extension, hook_fn(extension), False)
+                context_manager = contextlib.contextmanager(
+                    types.MethodType(hook_fn, extension)
+                )
+                return WrappedHook(
+                    extension=extension, hook=context_manager, is_async=False
+                )
 
             if inspect.isasyncgenfunction(hook_fn):
-                return WrappedHook(extension, hook_fn(extension), True)
+                context_manager_async = contextlib.asynccontextmanager(
+                    types.MethodType(hook_fn, extension)
+                )
+                return WrappedHook(
+                    extension=extension, hook=context_manager_async, is_async=True
+                )
 
             if callable(hook_fn):
                 return self.from_callable(extension, hook_fn)
@@ -96,27 +115,31 @@ class ExtensionContextManagerBase:
     ) -> WrappedHook:
         if iscoroutinefunction(on_start) or iscoroutinefunction(on_end):
 
-            async def iterator():
+            @contextlib.asynccontextmanager
+            async def iterator() -> AsyncIterator:
                 if on_start:
                     await await_maybe(on_start())
+
                 yield
+
                 if on_end:
                     await await_maybe(on_end())
 
-            hook = iterator()
-            return WrappedHook(extension, hook, True)
+            return WrappedHook(extension=extension, hook=iterator, is_async=True)
 
         else:
 
-            def iterator():
+            @contextlib.contextmanager
+            def iterator_async() -> Iterator[None]:
                 if on_start:
                     on_start()
+
                 yield
+
                 if on_end:
                     on_end()
 
-            hook = iterator()
-            return WrappedHook(extension, hook, False)
+            return WrappedHook(extension=extension, hook=iterator_async, is_async=False)
 
     @staticmethod
     def from_callable(
@@ -125,78 +148,61 @@ class ExtensionContextManagerBase:
     ) -> WrappedHook:
         if iscoroutinefunction(func):
 
-            async def async_iterator():
+            @contextlib.asynccontextmanager
+            async def iterator() -> AsyncIterator[None]:
                 await func(extension)
                 yield
 
-            hook = async_iterator()
-            return WrappedHook(extension, hook, True)
+            return WrappedHook(extension=extension, hook=iterator, is_async=True)
         else:
 
-            def iterator():
+            @contextlib.contextmanager
+            def iterator() -> Iterator[None]:
                 func(extension)
                 yield
 
-            hook = iterator()
-            return WrappedHook(extension, hook, False)
+            return WrappedHook(extension=extension, hook=iterator, is_async=False)
 
-    def run_hooks_sync(self, is_exit: bool = False) -> None:
-        """Run extensions synchronously."""
-        ctx = (
-            contextlib.suppress(StopIteration, StopAsyncIteration)
-            if is_exit
-            else contextlib.nullcontext()
-        )
-        for hook in self.hooks:
-            with ctx:
-                if hook.is_async:
-                    raise RuntimeError(
-                        f"SchemaExtension hook {hook.extension}.{self.HOOK_NAME} "
-                        "failed to complete synchronously."
-                    )
-                else:
-                    hook.initialized_hook.__next__()  # type: ignore[union-attr]
-
-    async def run_hooks_async(self, is_exit: bool = False) -> None:
-        """Run extensions asynchronously with support for sync lifecycle hooks.
-
-        The ``is_exit`` flag is required as a `StopIteration` cannot be raised from
-        within a coroutine.
-        """
-        ctx = (
-            contextlib.suppress(StopIteration, StopAsyncIteration)
-            if is_exit
-            else contextlib.nullcontext()
-        )
+    def __enter__(self) -> None:
+        self.exit_stack = contextlib.ExitStack()
 
-        for hook in self.hooks:
-            with ctx:
-                if hook.is_async:
-                    await hook.initialized_hook.__anext__()  # type: ignore[union-attr]
-                else:
-                    hook.initialized_hook.__next__()  # type: ignore[union-attr]
+        self.exit_stack.__enter__()
 
-    def __enter__(self):
-        self.run_hooks_sync()
+        for hook in self.hooks:
+            if hook.is_async:
+                raise RuntimeError(
+                    f"SchemaExtension hook {hook.extension}.{self.HOOK_NAME} "
+                    "failed to complete synchronously."
+                )
+            else:
+                self.exit_stack.enter_context(hook.hook())  # type: ignore
 
     def __exit__(
         self,
         exc_type: Optional[Type[BaseException]],
         exc_val: Optional[BaseException],
         exc_tb: Optional[TracebackType],
-    ):
-        self.run_hooks_sync(is_exit=True)
+    ) -> None:
+        self.exit_stack.__exit__(exc_type, exc_val, exc_tb)
 
-    async def __aenter__(self):
-        await self.run_hooks_async()
+    async def __aenter__(self) -> None:
+        self.async_exit_stack = contextlib.AsyncExitStack()
+
+        await self.async_exit_stack.__aenter__()
+
+        for hook in self.hooks:
+            if hook.is_async:
+                await self.async_exit_stack.enter_async_context(hook.hook())  # type: ignore
+            else:
+                self.async_exit_stack.enter_context(hook.hook())  # type: ignore
 
     async def __aexit__(
         self,
         exc_type: Optional[Type[BaseException]],
         exc_val: Optional[BaseException],
         exc_tb: Optional[TracebackType],
-    ):
-        await self.run_hooks_async(is_exit=True)
+    ) -> None:
+        await self.async_exit_stack.__aexit__(exc_type, exc_val, exc_tb)
 
 
 class OperationContextManager(ExtensionContextManagerBase):

strawberry/extensions/disable_validation.py

@@ -21,7 +21,7 @@ class DisableValidation(SchemaExtension):
 
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         # There aren't any arguments to this extension yet but we might add
         # some in the future
         pass

strawberry/extensions/mask_errors.py

@@ -18,7 +18,7 @@ class MaskErrors(SchemaExtension):
         self,
         should_mask_error: Callable[[GraphQLError], bool] = default_should_mask_error,
         error_message: str = "Unexpected error.",
-    ):
+    ) -> None:
         self.should_mask_error = should_mask_error
         self.error_message = error_message
 

strawberry/extensions/max_aliases.py

@@ -37,14 +37,14 @@ class MaxAliasesLimiter(AddValidationRules):
     def __init__(
         self,
         max_alias_count: int,
-    ):
+    ) -> None:
         validator = create_validator(max_alias_count)
         super().__init__([validator])
 
 
 def create_validator(max_alias_count: int) -> Type[ValidationRule]:
     class MaxAliasesValidator(ValidationRule):
-        def __init__(self, validation_context: ValidationContext):
+        def __init__(self, validation_context: ValidationContext) -> None:
             document = validation_context.document
             def_that_can_contain_alias = (
                 def_

strawberry/extensions/max_tokens.py

@@ -36,7 +36,7 @@ class MaxTokensLimiter(SchemaExtension):
     def __init__(
         self,
         max_token_count: int,
-    ):
+    ) -> None:
         self.max_token_count = max_token_count
 
     def on_operation(self) -> Iterator[None]:

strawberry/extensions/parser_cache.py

@@ -30,7 +30,7 @@ class ParserCache(SchemaExtension):
 
     """
 
-    def __init__(self, maxsize: Optional[int] = None):
+    def __init__(self, maxsize: Optional[int] = None) -> None:
         self.cached_parse_document = lru_cache(maxsize=maxsize)(parse_document)
 
     def on_parse(self) -> Iterator[None]:

strawberry/extensions/query_depth_limiter.py

@@ -114,7 +114,7 @@ class QueryDepthLimiter(AddValidationRules):
         max_depth: int,
         callback: Optional[Callable[[Dict[str, int]], None]] = None,
         should_ignore: Optional[ShouldIgnoreType] = None,
-    ):
+    ) -> None:
         if should_ignore is not None and not callable(should_ignore):
             raise TypeError(
                 "The `should_ignore` argument to "
@@ -130,7 +130,7 @@ def create_validator(
     callback: Optional[Callable[[Dict[str, int]], None]] = None,
 ) -> Type[ValidationRule]:
     class DepthLimitValidator(ValidationRule):
-        def __init__(self, validation_context: ValidationContext):
+        def __init__(self, validation_context: ValidationContext) -> None:
             document = validation_context.document
             definitions = document.definitions
 

strawberry/extensions/runner.py

@@ -28,7 +28,7 @@ class SchemaExtensionsRunner:
         extensions: Optional[
             List[Union[Type[SchemaExtension], SchemaExtension]]
         ] = None,
-    ):
+    ) -> None:
         self.execution_context = execution_context
 
         if not extensions:

strawberry/extensions/tracing/__init__.py

@@ -1,5 +1,5 @@
 import importlib
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from .apollo import ApolloTracingExtension, ApolloTracingExtensionSync
@@ -22,7 +22,7 @@ __all__ = [
 ]
 
 
-def __getattr__(name: str):
+def __getattr__(name: str) -> Any:
     if name in {"DatadogTracingExtension", "DatadogTracingExtensionSync"}:
         return getattr(importlib.import_module(".datadog", __name__), name)
 

strawberry/extensions/tracing/apollo.py

@@ -80,7 +80,7 @@ class ApolloTracingStats:
 
 
 class ApolloTracingExtension(SchemaExtension):
-    def __init__(self, execution_context: ExecutionContext):
+    def __init__(self, execution_context: ExecutionContext) -> None:
         self._resolver_stats: List[ApolloResolverStats] = []
         self.execution_context = execution_context
 

strawberry/extensions/tracing/datadog.py

@@ -21,12 +21,12 @@ class DatadogTracingExtension(SchemaExtension):
         self,
         *,
         execution_context: Optional[ExecutionContext] = None,
-    ):
+    ) -> None:
         if execution_context:
             self.execution_context = execution_context
 
     @cached_property
-    def _resource_name(self):
+    def _resource_name(self) -> str:
         assert self.execution_context.query
 
         query_hash = self.hash_query(self.execution_context.query)

strawberry/extensions/tracing/opentelemetry.py

@@ -45,7 +45,7 @@ class OpenTelemetryExtension(SchemaExtension):
         *,
         execution_context: Optional[ExecutionContext] = None,
         arg_filter: Optional[ArgFilter] = None,
-    ):
+    ) -> None:
         self._arg_filter = arg_filter
         self._tracer = trace.get_tracer("strawberry")
         if execution_context:

strawberry/extensions/tracing/sentry.py

@@ -22,7 +22,7 @@ class SentryTracingExtension(SchemaExtension):
         self,
         *,
         execution_context: Optional[ExecutionContext] = None,
-    ):
+    ) -> None:
         warnings.warn(
             "The Sentry tracing extension is deprecated, please update to sentry>=1.32.0",
             DeprecationWarning,
@@ -33,7 +33,7 @@ class SentryTracingExtension(SchemaExtension):
             self.execution_context = execution_context
 
     @cached_property
-    def _resource_name(self):
+    def _resource_name(self) -> str:
         assert self.execution_context.query
 
         query_hash = self.hash_query(self.execution_context.query)

strawberry/extensions/validation_cache.py

@@ -30,7 +30,7 @@ class ValidationCache(SchemaExtension):
 
     """
 
-    def __init__(self, maxsize: Optional[int] = None):
+    def __init__(self, maxsize: Optional[int] = None) -> None:
         self.cached_validate_document = lru_cache(maxsize=maxsize)(validate_document)
 
     def on_validate(self) -> Iterator[None]:

strawberry/fastapi/router.py

@@ -8,9 +8,12 @@ from typing import (
     Any,
     Awaitable,
     Callable,
+    Dict,
+    List,
     Mapping,
     Optional,
     Sequence,
+    Type,
     Union,
     cast,
 )
@@ -20,12 +23,16 @@ from starlette.background import BackgroundTasks  # noqa: TCH002
 from starlette.requests import HTTPConnection, Request
 from starlette.responses import (
     HTMLResponse,
+    JSONResponse,
     PlainTextResponse,
     Response,
 )
 from starlette.websockets import WebSocket
 
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, params
+from fastapi.datastructures import Default
+from fastapi.routing import APIRoute
+from fastapi.utils import generate_unique_id
 from strawberry.exceptions import InvalidCustomContext
 from strawberry.fastapi.context import BaseContext, CustomContext
 from strawberry.fastapi.handlers import GraphQLTransportWSHandler, GraphQLWSHandler
@@ -42,7 +49,10 @@ from strawberry.http.typevars import (
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
 
 if TYPE_CHECKING:
-    from starlette.types import ASGIApp
+    from enum import Enum
+
+    from starlette.routing import BaseRoute
+    from starlette.types import ASGIApp, Lifespan
 
     from strawberry.fastapi.context import MergedContext
     from strawberry.http import GraphQLHTTPResponse
@@ -52,7 +62,7 @@ if TYPE_CHECKING:
 
 
 class FastAPIRequestAdapter(AsyncHTTPRequestAdapter):
-    def __init__(self, request: Request):
+    def __init__(self, request: Request) -> None:
         self.request = request
 
     @property
@@ -89,7 +99,7 @@ class GraphQLRouter(
     request_adapter_class = FastAPIRequestAdapter
 
     @staticmethod
-    async def __get_root_value():
+    async def __get_root_value() -> None:
         return None
 
     @staticmethod
@@ -160,14 +170,46 @@ class GraphQLRouter(
             GRAPHQL_WS_PROTOCOL,
         ),
         connection_init_wait_timeout: timedelta = timedelta(minutes=1),
+        prefix: str = "",
+        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,
+        redirect_slashes: bool = True,
         default: Optional[ASGIApp] = None,
+        dependency_overrides_provider: Optional[Any] = None,
+        route_class: Type[APIRoute] = APIRoute,
         on_startup: Optional[Sequence[Callable[[], Any]]] = None,
         on_shutdown: Optional[Sequence[Callable[[], Any]]] = None,
-    ):
+        lifespan: Optional[Lifespan[Any]] = None,
+        deprecated: Optional[bool] = None,
+        include_in_schema: bool = True,
+        generate_unique_id_function: Callable[[APIRoute], str] = Default(
+            generate_unique_id
+        ),
+        **kwargs: Any,
+    ) -> None:
         super().__init__(
+            prefix=prefix,
+            tags=tags,
+            dependencies=dependencies,
+            default_response_class=default_response_class,
+            responses=responses,
+            callbacks=callbacks,
+            routes=routes,
+            redirect_slashes=redirect_slashes,
             default=default,
+            dependency_overrides_provider=dependency_overrides_provider,
+            route_class=route_class,
             on_startup=on_startup,
             on_shutdown=on_shutdown,
+            lifespan=lifespan,
+            deprecated=deprecated,
+            include_in_schema=include_in_schema,
+            generate_unique_id_function=generate_unique_id_function,
+            **kwargs,
         )
         self.schema = schema
         self.allow_queries_via_get = allow_queries_via_get

strawberry/federation/schema.py

@@ -66,7 +66,7 @@ class Schema(BaseSchema):
         ] = None,
         schema_directives: Iterable[object] = (),
         enable_federation_2: bool = False,
-    ):
+    ) -> None:
         query = self._get_federation_query_type(query)
 
         super().__init__(

strawberry/federation/schema_directives.py

@@ -92,7 +92,7 @@ class Link:
         as_: Optional[str] = UNSET,
         for_: Optional[LinkPurpose] = UNSET,
         import_: Optional[List[Optional[LinkImport]]] = UNSET,
-    ):
+    ) -> None:
         self.url = url
         self.as_ = as_
         self.for_ = for_

strawberry/field.py

@@ -90,7 +90,7 @@ class StrawberryField(dataclasses.Field):
         deprecation_reason: Optional[str] = None,
         directives: Sequence[object] = (),
         extensions: List[FieldExtension] = (),  # type: ignore
-    ):
+    ) -> None:
         # basic fields are fields with no provided resolver
         is_basic_field = not base_resolver
 
@@ -242,7 +242,7 @@ class StrawberryField(dataclasses.Field):
         return self._arguments
 
     @arguments.setter
-    def arguments(self, value: List[StrawberryArgument]):
+    def arguments(self, value: List[StrawberryArgument]) -> None:
         self._arguments = value
 
     @property

strawberry/flask/views.py

@@ -22,7 +22,7 @@ if TYPE_CHECKING:
 
 
 class FlaskHTTPRequestAdapter(SyncHTTPRequestAdapter):
-    def __init__(self, request: Request):
+    def __init__(self, request: Request) -> None:
         self.request = request
 
     @property
@@ -64,7 +64,7 @@ class BaseGraphQLView:
         graphiql: Optional[bool] = None,
         graphql_ide: Optional[GraphQL_IDE] = "graphiql",
         allow_queries_via_get: bool = True,
-    ):
+    ) -> None:
         self.schema = schema
         self.graphiql = graphiql
         self.allow_queries_via_get = allow_queries_via_get
@@ -119,7 +119,7 @@ class GraphQLView(
 
 
 class AsyncFlaskHTTPRequestAdapter(AsyncHTTPRequestAdapter):
-    def __init__(self, request: Request):
+    def __init__(self, request: Request) -> None:
         self.request = request
 
     @property

strawberry/http/exceptions.py

@@ -1,4 +1,4 @@
 class HTTPException(Exception):
-    def __init__(self, status_code: int, reason: str):
+    def __init__(self, status_code: int, reason: str) -> None:
         self.status_code = status_code
         self.reason = reason

strawberry/lazy_type.py

@@ -4,7 +4,20 @@ import sys
 import warnings
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, ForwardRef, Generic, Optional, Tuple, Type, TypeVar, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    ForwardRef,
+    Generic,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    cast,
+)
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
 
 TypeName = TypeVar("TypeName")
 Module = TypeVar("Module")
@@ -16,7 +29,7 @@ class LazyType(Generic[TypeName, Module]):
     module: str
     package: Optional[str] = None
 
-    def __class_getitem__(cls, params: Tuple[str, str]):
+    def __class_getitem__(cls, params: Tuple[str, str]) -> "Self":
         warnings.warn(
             (
                 "LazyType is deprecated, use "
@@ -63,7 +76,7 @@ class LazyType(Generic[TypeName, Module]):
     # this empty call method allows LazyTypes to be used in generic types
     # for example: List[LazyType["A", "module"]]
 
-    def __call__(self):  # pragma: no cover
+    def __call__(self) -> None:  # pragma: no cover
         return None
 
 

strawberry/litestar/controller.py

@@ -325,10 +325,10 @@ class GraphQLController(
         context_ws: Any,
         root_value: Any,
     ) -> None:
-        async def _get_context():
+        async def _get_context() -> Any:
             return context_ws
 
-        async def _get_root_value():
+        async def _get_root_value() -> Any:
             return root_value
 
         preferred_protocol = self.pick_preferred_protocol(socket)

strawberry/litestar/handlers/graphql_transport_ws_handler.py

@@ -20,7 +20,7 @@ class GraphQLTransportWSHandler(BaseGraphQLTransportWSHandler):
         get_context: Callable,
         get_root_value: Callable,
         ws: WebSocket,
-    ):
+    ) -> None:
         super().__init__(schema, debug, connection_init_wait_timeout)
         self._get_context = get_context
         self._get_root_value = get_root_value