strawberry-graphql 0.166.0__py3-none-any.whl → 0.167.1__py3-none-any.whl

strawberry/aiohttp/test/client.py

@@ -1,4 +1,11 @@
-from typing import Dict, Mapping, Optional
+from __future__ import annotations
+
+from typing import (
+    Any,
+    Dict,
+    Mapping,
+    Optional,
+)
 
 from strawberry.test.client import BaseGraphQLTestClient, Response
 
@@ -33,10 +40,11 @@ class GraphQLTestClient(BaseGraphQLTestClient):
         body: Dict[str, object],
         headers: Optional[Dict[str, object]] = None,
         files: Optional[Dict[str, object]] = None,
-    ):
+    ) -> Any:
         response = await self._client.post(
             self.url,
             json=body if not files else None,
             data=body if files else None,
         )
+
         return response

strawberry/annotation.py

@@ -115,7 +115,7 @@ class StrawberryAnnotation:
         # ... raise NotImplementedError(f"Unknown type {evaled_type}")
         return evaled_type
 
-    def set_namespace_from_field(self, field: StrawberryField):
+    def set_namespace_from_field(self, field: StrawberryField) -> None:
         module = sys.modules[field.origin.__module__]
         self.namespace = module.__dict__
 

strawberry/asgi/handlers/http_handler.py

@@ -19,6 +19,7 @@ if TYPE_CHECKING:
     from starlette.types import Receive, Scope, Send
 
     from strawberry.schema import BaseSchema
+    from strawberry.types.execution import ExecutionResult
 
 
 class HTTPHandler:
@@ -42,7 +43,7 @@ class HTTPHandler:
         self.process_result = process_result
         self.encode_json = encode_json
 
-    async def handle(self, scope: Scope, receive: Receive, send: Send):
+    async def handle(self, scope: Scope, receive: Receive, send: Send) -> None:
         request = Request(scope=scope, receive=receive)
         root_value = await self.get_root_value(request)
 
@@ -199,7 +200,7 @@ class HTTPHandler:
         operation_name: Optional[str] = None,
         root_value: Any = None,
         allowed_operation_types: Optional[Iterable[OperationType]] = None,
-    ):
+    ) -> ExecutionResult:
         if self.debug:
             pretty_print_graphql_operation(operation_name, query, variables)
 

strawberry/asgi/test/client.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import json
-from typing import TYPE_CHECKING, Dict, Mapping, Optional
+from typing import TYPE_CHECKING, Any, Dict, Mapping, Optional
 
 from strawberry.test import BaseGraphQLTestClient
 
@@ -37,7 +37,7 @@ class GraphQLTestClient(BaseGraphQLTestClient):
         body: Dict[str, object],
         headers: Optional[Dict[str, object]] = None,
         files: Optional[Dict[str, object]] = None,
-    ):
+    ) -> Any:
         return self._client.post(
             self.url,
             json=body if not files else None,

strawberry/chalice/views.py

@@ -37,6 +37,7 @@ class GraphQLView:
                 "The `render_graphiql` argument is deprecated. "
                 "Use `graphiql` instead.",
                 DeprecationWarning,
+                stacklevel=2,
             )
         else:
             self.graphiql = graphiql

strawberry/channels/context.py

@@ -15,7 +15,7 @@ class StrawberryChannelsContext:
     connection_params: Optional[Dict[str, Any]] = None
 
     @property
-    def ws(self):
+    def ws(self) -> "ChannelsConsumer":
         return self.request
 
     def __getitem__(self, item: str) -> Any:

strawberry/channels/handlers/base.py

@@ -94,7 +94,7 @@ class ChannelsConsumer(AsyncConsumer):
             request=request or self, connection_params=connection_params
         )
 
-    async def dispatch(self, message: ChannelsMessage):
+    async def dispatch(self, message: ChannelsMessage) -> None:
         # AsyncConsumer will try to get a function for message["type"] to handle
         # for both http/websocket types and also for layers communication.
         # In case the type isn't one of those, pass it to the listen queue so

strawberry/channels/handlers/graphql_transport_ws_handler.py

@@ -54,7 +54,7 @@ class GraphQLTransportWSHandler(BaseGraphQLTransportWSHandler):
     async def handle_request(self) -> Any:
         await self._ws.accept(subprotocol=GRAPHQL_TRANSPORT_WS_PROTOCOL)
 
-    async def handle_disconnect(self, code):
+    async def handle_disconnect(self, code) -> None:
         for operation_id in list(self.subscriptions.keys()):
             await self.cleanup_operation(operation_id)
 

strawberry/channels/handlers/graphql_ws_handler.py

@@ -46,7 +46,7 @@ class GraphQLWSHandler(BaseGraphQLWSHandler):
     async def handle_request(self) -> Any:
         await self._ws.accept(subprotocol=GRAPHQL_WS_PROTOCOL)
 
-    async def handle_disconnect(self, code):
+    async def handle_disconnect(self, code) -> None:
         if self.keep_alive_task:
             self.keep_alive_task.cancel()
             with suppress(BaseException):

strawberry/channels/handlers/http_handler.py

@@ -81,7 +81,7 @@ class GraphQLHTTPConsumer(ChannelsConsumer, AsyncHttpConsumer):
         self.subscriptions_enabled = subscriptions_enabled
         super().__init__(**kwargs)
 
-    async def handle(self, body: bytes):
+    async def handle(self, body: bytes) -> None:
         try:
             if self.scope["method"] == "GET":
                 result = await self.get(body)
@@ -157,7 +157,7 @@ class GraphQLHTTPConsumer(ChannelsConsumer, AsyncHttpConsumer):
     async def parse_multipart_body(self, body: bytes) -> GraphQLRequestData:
         raise ExecutionError("Unable to parse the multipart body")
 
-    async def execute(self, request_data: GraphQLRequestData):
+    async def execute(self, request_data: GraphQLRequestData) -> GraphQLHTTPResponse:
         context = await self.get_context()
         root_value = await self.get_root_value()
 
@@ -179,11 +179,11 @@ class GraphQLHTTPConsumer(ChannelsConsumer, AsyncHttpConsumer):
     async def process_result(self, result: ExecutionResult) -> GraphQLHTTPResponse:
         return process_result(result)
 
-    async def render_graphiql(self, body):
+    async def render_graphiql(self, body) -> Result:
         html = get_graphiql_html(self.subscriptions_enabled)
         return Result(response=html.encode(), content_type="text/html")
 
-    def should_render_graphiql(self):
+    def should_render_graphiql(self) -> bool:
         accept_list = self.headers.get("accept", "").split(",")
         return self.graphiql and any(
             accepted in accept_list for accepted in ["text/html", "*/*"]
@@ -216,7 +216,7 @@ class SyncGraphQLHTTPConsumer(GraphQLHTTPConsumer):
     # handlers in a threadpool. Check SyncConsumer's documentation for more info:
     # https://github.com/django/channels/blob/main/channels/consumer.py#L104
     @database_sync_to_async
-    def execute(self, request_data: GraphQLRequestData):
+    def execute(self, request_data: GraphQLRequestData) -> GraphQLHTTPResponse:
         context = self.get_context(self)
         root_value = self.get_root_value(self)
 

strawberry/channels/handlers/ws_handler.py

@@ -69,7 +69,7 @@ class GraphQLWSConsumer(ChannelsWSConsumer):
         sorted_intersection = sorted(intersection, key=accepted_subprotocols.index)
         return next(iter(sorted_intersection), None)
 
-    async def connect(self):
+    async def connect(self) -> None:
         preferred_protocol = self.pick_preferred_protocol(self.scope["subprotocols"])
 
         if preferred_protocol == GRAPHQL_TRANSPORT_WS_PROTOCOL:
@@ -98,15 +98,15 @@ class GraphQLWSConsumer(ChannelsWSConsumer):
         await self._handler.handle()
         return None
 
-    async def receive(self, *args, **kwargs):
+    async def receive(self, *args, **kwargs) -> None:
         # Overriding this so that we can pass the errors to handle_invalid_message
         try:
             await super().receive(*args, **kwargs)
         except ValueError as e:
             await self._handler.handle_invalid_message(str(e))
 
-    async def receive_json(self, content, **kwargs):
+    async def receive_json(self, content, **kwargs) -> None:
         await self._handler.handle_message(content)
 
-    async def disconnect(self, code):
+    async def disconnect(self, code) -> None:
         await self._handler.handle_disconnect(code)

strawberry/channels/testing.py

@@ -77,7 +77,7 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
     async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
         await self.disconnect()
 
-    async def gql_init(self):
+    async def gql_init(self) -> None:
         res = await self.connect()
         if self.protocol == GRAPHQL_TRANSPORT_WS_PROTOCOL:
             assert res == (True, GRAPHQL_TRANSPORT_WS_PROTOCOL)

strawberry/cli/__init__.py

@@ -6,7 +6,7 @@ from .commands.server import server as cmd_server
 
 
 @click.group()
-def run():  # pragma: no cover
+def run() -> None:  # pragma: no cover
     pass
 
 

strawberry/cli/commands/codegen.py

@@ -87,7 +87,7 @@ class ConsolePlugin(QueryCodegenPlugin):
         self.output_dir = output_dir
         self.plugins = plugins
 
-    def on_start(self):
+    def on_start(self) -> None:
         click.echo(
             click.style(
                 "The codegen is experimental. Please submit any bug at "
@@ -107,7 +107,7 @@ class ConsolePlugin(QueryCodegenPlugin):
             )
         )
 
-    def on_end(self, result: CodegenResult):
+    def on_end(self, result: CodegenResult) -> None:
         self.output_dir.mkdir(parents=True, exist_ok=True)
         result.write(self.output_dir)
 
@@ -148,7 +148,7 @@ def codegen(
     output_dir: Path,
     selected_plugins: List[str],
     cli_plugin: Optional[str] = None,
-):
+) -> None:
     schema_symbol = load_schema(schema, app_dir)
 
     console_plugin = _load_plugin(cli_plugin) if cli_plugin else ConsolePlugin

strawberry/cli/commands/export_schema.py

@@ -17,7 +17,7 @@ from strawberry.printer import print_schema
         "Works the same as `--app-dir` in uvicorn."
     ),
 )
-def export_schema(schema: str, app_dir: str):
+def export_schema(schema: str, app_dir: str) -> None:
     schema_symbol = load_schema(schema, app_dir)
 
     print(print_schema(schema_symbol))  # noqa: T201

strawberry/cli/commands/server.py

@@ -38,7 +38,7 @@ from strawberry.cli.utils import load_schema
     show_default=True,
     help="Log GraphQL operations",
 )
-def server(schema, host, port, log_level, app_dir, log_operations):
+def server(schema, host, port, log_level, app_dir, log_operations) -> None:
     sys.path.insert(0, app_dir)
 
     try:

strawberry/custom_scalar.py

@@ -32,7 +32,7 @@ else:
     _T = TypeVar("_T", bound=type)
 
 
-def identity(x):
+def identity(x: _T) -> _T:
     return x
 
 

strawberry/dataloader.py

@@ -44,7 +44,7 @@ class Batch(Generic[K, T]):
     tasks: List[LoaderTask] = dataclasses.field(default_factory=list)
     dispatched: bool = False
 
-    def add_task(self, key: Any, future: Future):
+    def add_task(self, key: Any, future: Future) -> None:
         task = LoaderTask[K, T](key, future)
         self.tasks.append(task)
 
@@ -71,7 +71,7 @@ class AbstractCache(Generic[K, T], ABC):
 
 
 class DefaultCache(AbstractCache[K, T]):
-    def __init__(self, cache_key_fn: Optional[Callable[[K], Hashable]] = None):
+    def __init__(self, cache_key_fn: Optional[Callable[[K], Hashable]] = None) -> None:
         self.cache_key_fn: Callable[[K], Hashable] = (
             cache_key_fn if cache_key_fn is not None else lambda x: x
         )
@@ -86,7 +86,7 @@ class DefaultCache(AbstractCache[K, T]):
     def delete(self, key: K) -> None:
         del self.cache_map[self.cache_key_fn(key)]
 
-    def clear(self):
+    def clear(self) -> None:
         self.cache_map.clear()
 
 
@@ -169,23 +169,23 @@ class DataLoader(Generic[K, T]):
     def load_many(self, keys: Iterable[K]) -> Awaitable[List[T]]:
         return gather(*map(self.load, keys))
 
-    def clear(self, key: K):
+    def clear(self, key: K) -> None:
         if self.cache:
             self.cache_map.delete(key)
 
-    def clear_many(self, keys: Iterable[K]):
+    def clear_many(self, keys: Iterable[K]) -> None:
         if self.cache:
             for key in keys:
                 self.cache_map.delete(key)
 
-    def clear_all(self):
+    def clear_all(self) -> None:
         if self.cache:
             self.cache_map.clear()
 
-    def prime(self, key: K, value: T, force: bool = False):
+    def prime(self, key: K, value: T, force: bool = False) -> None:
         self.prime_many({key: value}, force)
 
-    def prime_many(self, data: Mapping[K, T], force: bool = False):
+    def prime_many(self, data: Mapping[K, T], force: bool = False) -> None:
         # Populate the cache with the specified values
         if self.cache:
             for key, value in data.items():
@@ -231,7 +231,7 @@ def get_current_batch(loader: DataLoader) -> Batch:
     return loader.batch
 
 
-def dispatch(loader: DataLoader, batch: Batch):
+def dispatch(loader: DataLoader, batch: Batch) -> None:
     loader.loop.call_soon(create_task, dispatch_batch(loader, batch))
 
 

strawberry/django/context.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from django.http import HttpRequest, HttpResponse
@@ -17,6 +17,6 @@ class StrawberryDjangoContext:
         # using info.context["request"]
         return super().__getattribute__(key)
 
-    def get(self, key: str):
+    def get(self, key: str) -> Any:
         """Enable .get notation for accessing the request"""
         return super().__getattribute__(key)

strawberry/django/test/client.py

@@ -1,4 +1,4 @@
-from typing import Dict, Optional
+from typing import Any, Dict, Optional
 
 from strawberry.test import BaseGraphQLTestClient
 
@@ -9,7 +9,7 @@ class GraphQLTestClient(BaseGraphQLTestClient):
         body: Dict[str, object],
         headers: Optional[Dict[str, object]] = None,
         files: Optional[Dict[str, object]] = None,
-    ):
+    ) -> Any:
         if files:
             return self._client.post(
                 self.url, data=body, format="multipart", headers=headers

strawberry/django/views.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import json
 import warnings
-from typing import TYPE_CHECKING, Any, Dict, Optional, Type
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Type, Union
 
 from django.core.exceptions import BadRequest, SuspiciousOperation
 from django.core.serializers.json import DjangoJSONEncoder
@@ -85,6 +85,7 @@ class BaseView(View):
             warnings.warn(
                 "json_dumps_params is deprecated, override encode_json instead",
                 DeprecationWarning,
+                stacklevel=2,
             )
 
             self.json_encoder = DjangoJSONEncoder
@@ -95,6 +96,7 @@ class BaseView(View):
             warnings.warn(
                 "json_encoder is deprecated, override encode_json instead",
                 DeprecationWarning,
+                stacklevel=2,
             )
 
     def parse_body(self, request: HttpRequest) -> Dict[str, Any]:
@@ -139,7 +141,7 @@ class BaseView(View):
 
         return parse_request_data(data)
 
-    def _render_graphiql(self, request: HttpRequest, context=None):
+    def _render_graphiql(self, request: HttpRequest, context=None) -> TemplateResponse:
         if not self.graphiql:
             raise Http404()
 
@@ -204,7 +206,9 @@ class GraphQLView(BaseView):
         return process_result(result)
 
     @method_decorator(csrf_exempt)
-    def dispatch(self, request, *args, **kwargs):
+    def dispatch(
+        self, request, *args, **kwargs
+    ) -> Union[HttpResponseNotAllowed, TemplateResponse, HttpResponse]:
         if not self.is_request_allowed(request):
             return HttpResponseNotAllowed(
                 ["GET", "POST"], "GraphQL only supports GET and POST requests."
@@ -250,7 +254,7 @@ class GraphQLView(BaseView):
 
 class AsyncGraphQLView(BaseView):
     @classonlymethod
-    def as_view(cls, **initkwargs):
+    def as_view(cls, **initkwargs) -> Callable[..., HttpResponse]:
         # This code tells django that this view is async, see docs here:
         # https://docs.djangoproject.com/en/3.1/topics/async/#async-views
 
@@ -259,7 +263,9 @@ class AsyncGraphQLView(BaseView):
         return view
 
     @method_decorator(csrf_exempt)
-    async def dispatch(self, request, *args, **kwargs):
+    async def dispatch(
+        self, request, *args, **kwargs
+    ) -> Union[HttpResponseNotAllowed, TemplateResponse, HttpResponse]:
         if not self.is_request_allowed(request):
             return HttpResponseNotAllowed(
                 ["GET", "POST"], "GraphQL only supports GET and POST requests."

strawberry/exceptions/handler.py

@@ -17,7 +17,7 @@ ExceptionHandler = Callable[
 ]
 
 
-def should_use_rich_exceptions():
+def should_use_rich_exceptions() -> bool:
     errors_disabled = os.environ.get("STRAWBERRY_DISABLE_RICH_ERRORS", "")
 
     return errors_disabled.lower() not in ["true", "1", "yes"]
@@ -53,7 +53,7 @@ def strawberry_exception_handler(
     exception_type: Type[BaseException],
     exception: BaseException,
     traceback: Optional[TracebackType],
-):
+) -> None:
     _get_handler(exception_type)(exception_type, exception, traceback)
 
 
@@ -64,7 +64,7 @@ def strawberry_threading_exception_handler(
         Optional[TracebackType],
         Optional[threading.Thread],
     ]
-):
+) -> None:
     (exception_type, exception, traceback, _) = args
 
     if exception is None:
@@ -81,14 +81,14 @@ def strawberry_threading_exception_handler(
     _get_handler(exception_type)(exception_type, exception, traceback)
 
 
-def reset_exception_handler():
+def reset_exception_handler() -> None:
     sys.excepthook = sys.__excepthook__
 
     if sys.version_info >= (3, 8):
         threading.excepthook = original_threading_exception_hook
 
 
-def setup_exception_handler():
+def setup_exception_handler() -> None:
     if should_use_rich_exceptions():
         sys.excepthook = strawberry_exception_handler
 

strawberry/exceptions/missing_arguments_annotations.py

@@ -39,7 +39,7 @@ class MissingArgumentsAnnotationsError(StrawberryException):
         self.annotation_message = f"{first}argument missing annotation"
 
     @property
-    def missing_arguments_str(self):
+    def missing_arguments_str(self) -> str:
         arguments = self.missing_arguments
 
         if len(arguments) == 1:

strawberry/experimental/pydantic/conversion.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import copy
 import dataclasses
-from typing import TYPE_CHECKING, Union, cast
+from typing import TYPE_CHECKING, Any, Union, cast
 
 from strawberry.enum import EnumDefinition
 from strawberry.type import StrawberryList, StrawberryOptional
@@ -64,12 +64,14 @@ def _convert_from_pydantic_to_strawberry_type(
     return data
 
 
-def convert_pydantic_model_to_strawberry_class(cls, *, model_instance=None, extra=None):
+def convert_pydantic_model_to_strawberry_class(
+    cls, *, model_instance=None, extra=None
+) -> Any:
     extra = extra or {}
     kwargs = {}
 
-    for field in cls._type_definition.fields:
-        field = cast("StrawberryField", field)
+    for field_ in cls._type_definition.fields:
+        field = cast("StrawberryField", field_)
         python_name = field.python_name
 
         data_from_extra = extra.get(python_name, None)
@@ -87,7 +89,7 @@ def convert_pydantic_model_to_strawberry_class(cls, *, model_instance=None, extr
     return cls(**kwargs)
 
 
-def convert_strawberry_class_to_pydantic_model(obj):
+def convert_strawberry_class_to_pydantic_model(obj) -> Any:
     if hasattr(obj, "to_pydantic"):
         return obj.to_pydantic()
     elif dataclasses.is_dataclass(obj):

strawberry/experimental/pydantic/error_type.py

@@ -2,7 +2,18 @@ from __future__ import annotations
 
 import dataclasses
 import warnings
-from typing import TYPE_CHECKING, Any, List, Optional, Sequence, Tuple, Type, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
 
 from pydantic import BaseModel
 from pydantic.utils import lenient_issubclass
@@ -23,13 +34,13 @@ if TYPE_CHECKING:
     from pydantic.fields import ModelField
 
 
-def get_type_for_field(field: ModelField):
+def get_type_for_field(field: ModelField) -> Union[Any, Type[None], Type[List]]:
     type_ = field.outer_type_
     type_ = normalize_type(type_)
     return field_type_to_type(type_)
 
 
-def field_type_to_type(type_):
+def field_type_to_type(type_) -> Union[Any, List[Any], None]:
     error_class: Any = str
     strawberry_type: Any = error_class
 
@@ -59,7 +70,7 @@ def error_type(
     description: Optional[str] = None,
     directives: Optional[Sequence[object]] = (),
     all_fields: bool = False,
-):
+) -> Callable[..., Type]:
     def wrap(cls):
         model_fields = model.__fields__
         fields_set = set(fields) if fields else set()
@@ -68,6 +79,7 @@ def error_type(
             warnings.warn(
                 "`fields` is deprecated, use `auto` type annotations instead",
                 DeprecationWarning,
+                stacklevel=2,
             )
 
         existing_fields = getattr(cls, "__annotations__", {})

strawberry/experimental/pydantic/fields.py

@@ -95,7 +95,7 @@ def get_basic_type(type_) -> Type[Any]:
     return type_
 
 
-def replace_pydantic_types(type_: Any, is_input: bool):
+def replace_pydantic_types(type_: Any, is_input: bool) -> Any:
     if lenient_issubclass(type_, BaseModel):
         attr = "_strawberry_input_type" if is_input else "_strawberry_type"
         if hasattr(type_, attr):

strawberry/experimental/pydantic/object_type.py

@@ -40,7 +40,7 @@ if TYPE_CHECKING:
     from pydantic.fields import ModelField
 
 
-def get_type_for_field(field: ModelField, is_input: bool):
+def get_type_for_field(field: ModelField, is_input: bool):  # noqa: ANN201
     outer_type = field.outer_type_
     replaced_type = replace_types_recursively(outer_type, is_input)
 
@@ -134,6 +134,7 @@ def type(
             warnings.warn(
                 "`fields` is deprecated, use `auto` type annotations instead",
                 DeprecationWarning,
+                stacklevel=2,
             )
 
         existing_fields = getattr(cls, "__annotations__", {})

strawberry/experimental/pydantic/utils.py

@@ -46,7 +46,7 @@ def normalize_type(type_) -> Any:
     return type_
 
 
-def get_strawberry_type_from_model(type_: Any):
+def get_strawberry_type_from_model(type_: Any) -> Any:
     if hasattr(type_, "_strawberry_type"):
         return type_._strawberry_type
     else:

strawberry/ext/dataclasses/dataclasses.py

@@ -11,9 +11,10 @@ from dataclasses import (  # type: ignore
     _field_init,
     _init_param,
 )
+from typing import Any
 
 
-def dataclass_init_fn(fields, frozen, has_post_init, self_name, globals_):
+def dataclass_init_fn(fields, frozen, has_post_init, self_name, globals_) -> Any:
     """
     We create a custom __init__ function for the dataclasses that back
     Strawberry object types to only accept keyword arguments. This allows us to

strawberry/ext/mypy_plugin.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import re
+import typing
 import warnings
 from decimal import Decimal
 from typing import (
@@ -905,7 +906,7 @@ class StrawberryPlugin(Plugin):
 
         return None
 
-    def get_type_analyze_hook(self, fullname: str):
+    def get_type_analyze_hook(self, fullname: str) -> Union[Callable[..., Type], None]:
         if self._is_strawberry_lazy_type(fullname):
             return lazy_type_analyze_callback
 
@@ -1030,14 +1031,15 @@ class StrawberryPlugin(Plugin):
         )
 
 
-def plugin(version: str):
+def plugin(version: str) -> typing.Type[StrawberryPlugin]:
     match = VERSION_RE.match(version)
     if match:
         MypyVersion.VERSION = Decimal(".".join(match.groups()))
     else:
         MypyVersion.VERSION = FALLBACK_VERSION
         warnings.warn(
-            f"Mypy version {version} could not be parsed. Reverting to v0.800"
+            f"Mypy version {version} could not be parsed. Reverting to v0.800",
+            stacklevel=1,
         )
 
     return StrawberryPlugin