strawberry-graphql 0.257.0.dev1735244504__py3-none-any.whl → 0.258.0__py3-none-any.whl

strawberry/relay/fields.py

@@ -37,6 +37,7 @@ from strawberry.relay.exceptions import (
 )
 from strawberry.types.arguments import StrawberryArgument, argument
 from strawberry.types.base import StrawberryList, StrawberryOptional
+from strawberry.types.cast import cast as strawberry_cast
 from strawberry.types.field import _RESOLVER_TYPE, StrawberryField, field
 from strawberry.types.fields.resolver import StrawberryResolver
 from strawberry.types.lazy_type import LazyType
@@ -88,12 +89,27 @@ class NodeExtension(FieldExtension):
             info: Info,
             id: Annotated[GlobalID, argument(description="The ID of the object.")],
         ) -> Union[Node, None, Awaitable[Union[Node, None]]]:
-            return id.resolve_type(info).resolve_node(
+            node_type = id.resolve_type(info)
+            resolved_node = node_type.resolve_node(
                 id.node_id,
                 info=info,
                 required=not is_optional,
             )
 
+            # We are using `strawberry_cast` here to cast the resolved node to make
+            # sure `is_type_of` will not try to find its type again. Very important
+            # when returning a non type (e.g. Django/SQLAlchemy/Pydantic model), as
+            # we could end up resolving to a different type in case more than one
+            # are registered.
+            if inspect.isawaitable(resolved_node):
+
+                async def resolve() -> Any:
+                    return strawberry_cast(node_type, await resolved_node)
+
+                return resolve()
+
+            return cast(Node, strawberry_cast(node_type, resolved_node))
+
         return resolver
 
     def get_node_list_resolver(
@@ -139,6 +155,14 @@ class NodeExtension(FieldExtension):
                 if inspect.isasyncgen(nodes)
             }
 
+            # We are using `strawberry_cast` here to cast the resolved node to make
+            # sure `is_type_of` will not try to find its type again. Very important
+            # when returning a non type (e.g. Django/SQLAlchemy/Pydantic model), as
+            # we could end up resolving to a different type in case more than one
+            # are registered
+            def cast_nodes(node_t: type[Node], nodes: Iterable[Any]) -> list[Node]:
+                return [cast(Node, strawberry_cast(node_t, node)) for node in nodes]
+
             if awaitable_nodes or asyncgen_nodes:
 
                 async def resolve(resolved: Any = resolved_nodes) -> list[Node]:
@@ -161,7 +185,8 @@ class NodeExtension(FieldExtension):
 
                     # Resolve any generator to lists
                     resolved = {
-                        node_t: list(nodes) for node_t, nodes in resolved.items()
+                        node_t: cast_nodes(node_t, nodes)
+                        for node_t, nodes in resolved.items()
                     }
                     return [
                         resolved[index_map[gid][0]][index_map[gid][1]] for gid in ids
@@ -171,7 +196,7 @@ class NodeExtension(FieldExtension):
 
             # Resolve any generator to lists
             resolved = {
-                node_t: list(cast(Iterator[Node], nodes))
+                node_t: cast_nodes(node_t, cast(Iterable[Node], nodes))
                 for node_t, nodes in resolved_nodes.items()
             }
             return [resolved[index_map[gid][0]][index_map[gid][1]] for gid in ids]
@@ -182,6 +207,9 @@ class NodeExtension(FieldExtension):
 class ConnectionExtension(FieldExtension):
     connection_type: type[Connection[Node]]
 
+    def __init__(self, max_results: Optional[int] = None) -> None:
+        self.max_results = max_results
+
     def apply(self, field: StrawberryField) -> None:
         field.arguments = [
             *field.arguments,
@@ -288,6 +316,7 @@ class ConnectionExtension(FieldExtension):
             after=after,
             first=first,
             last=last,
+            max_results=self.max_results,
         )
 
     async def resolve_async(
@@ -316,6 +345,7 @@ class ConnectionExtension(FieldExtension):
             after=after,
             first=first,
             last=last,
+            max_results=self.max_results,
         )
 
         # If nodes was an AsyncIterable/AsyncIterator, resolve_connection
@@ -357,6 +387,7 @@ def connection(
     metadata: Optional[Mapping[Any, Any]] = None,
     directives: Optional[Sequence[object]] = (),
     extensions: list[FieldExtension] = (),  # type: ignore
+    max_results: Optional[int] = 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
     # any behaviour at the moment.
@@ -389,6 +420,9 @@ def connection(
         metadata: The metadata of the field.
         directives: The directives to apply to the field.
         extensions: The extensions to apply to the field.
+        max_results: The maximum number of results this connection can return.
+            Can be set to override the default value of 100 defined in the
+            schema configuration.
         init: Used only for type checking purposes.
 
     Examples:
@@ -451,7 +485,7 @@ def connection(
         default_factory=default_factory,
         metadata=metadata,
         directives=directives or (),
-        extensions=[*extensions, ConnectionExtension()],
+        extensions=[*extensions, ConnectionExtension(max_results=max_results)],
     )
     if resolver is not None:
         f = f(resolver)

strawberry/relay/types.py

@@ -717,6 +717,7 @@ class Connection(Generic[NodeType]):
         after: Optional[str] = None,
         first: Optional[int] = None,
         last: Optional[int] = None,
+        max_results: Optional[int] = None,
         **kwargs: Any,
     ) -> AwaitableOrValue[Self]:
         """Resolve a connection from nodes.
@@ -731,6 +732,7 @@ class Connection(Generic[NodeType]):
             after: Returns the items in the list that come after the specified cursor.
             first: Returns the first n items from the list.
             last: Returns the items in the list that come after the specified cursor.
+            max_results: The maximum number of results to resolve.
             kwargs: Additional arguments passed to the resolver.
 
         Returns:
@@ -758,7 +760,7 @@ class ListConnection(Connection[NodeType]):
     )
 
     @classmethod
-    def resolve_connection(
+    def resolve_connection(  # noqa: PLR0915
         cls,
         nodes: NodeIterableType[NodeType],
         *,
@@ -767,6 +769,7 @@ class ListConnection(Connection[NodeType]):
         after: Optional[str] = None,
         first: Optional[int] = None,
         last: Optional[int] = None,
+        max_results: Optional[int] = None,
         **kwargs: Any,
     ) -> AwaitableOrValue[Self]:
         """Resolve a connection from the list of nodes.
@@ -780,6 +783,7 @@ class ListConnection(Connection[NodeType]):
             after: Returns the items in the list that come after the specified cursor.
             first: Returns the first n items from the list.
             last: Returns the items in the list that come after the specified cursor.
+            max_results: The maximum number of results to resolve.
             kwargs: Additional arguments passed to the resolver.
 
         Returns:
@@ -794,6 +798,7 @@ class ListConnection(Connection[NodeType]):
             after=after,
             first=first,
             last=last,
+            max_results=max_results,
         )
 
         type_def = get_object_definition(cls)

strawberry/relay/utils.py

@@ -131,11 +131,16 @@ class SliceMetadata:
         after: str | None = None,
         first: int | None = None,
         last: int | None = None,
+        max_results: int | None = None,
     ) -> Self:
         """Get the slice metadata to use on ListConnection."""
         from strawberry.relay.types import PREFIX
 
-        max_results = info.schema.config.relay_max_results
+        max_results = (
+            max_results
+            if max_results is not None
+            else info.schema.config.relay_max_results
+        )
         start = 0
         end: int | None = None
 

strawberry/schema/base.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-from functools import lru_cache
 from typing import TYPE_CHECKING, Any, Optional, Union
 from typing_extensions import Protocol
 
@@ -88,7 +87,6 @@ class BaseSchema(Protocol):
         raise NotImplementedError
 
     @abstractmethod
-    @lru_cache
     def get_directive_by_name(self, graphql_name: str) -> Optional[StrawberryDirective]:
         raise NotImplementedError
 

strawberry/schema/execute.py

@@ -85,7 +85,7 @@ async def _parse_and_validate_async(
     context: ExecutionContext, extensions_runner: SchemaExtensionsRunner
 ) -> Optional[PreExecutionError]:
     if not context.query:
-        raise MissingQueryError()
+        raise MissingQueryError
 
     async with extensions_runner.parsing():
         try:
@@ -96,7 +96,7 @@ async def _parse_and_validate_async(
             context.errors = [error]
             return PreExecutionError(data=None, errors=[error])
 
-        except Exception as error:
+        except Exception as error:  # noqa: BLE001
             error = GraphQLError(str(error), original_error=error)
             context.errors = [error]
             return PreExecutionError(data=None, errors=[error])
@@ -189,9 +189,9 @@ async def execute(
                     # only return a sanitised version to the client.
                     process_errors(result.errors, execution_context)
 
-    except (MissingQueryError, InvalidOperationTypeError) as e:
-        raise e
-    except Exception as exc:
+    except (MissingQueryError, InvalidOperationTypeError):
+        raise
+    except Exception as exc:  # noqa: BLE001
         return await _handle_execution_result(
             execution_context,
             PreExecutionError(data=None, errors=[_coerce_error(exc)]),
@@ -219,7 +219,7 @@ def execute_sync(
             # Note: In graphql-core the schema would be validated here but in
             # Strawberry we are validating it at initialisation time instead
             if not execution_context.query:
-                raise MissingQueryError()
+                raise MissingQueryError  # noqa: TRY301
 
             with extensions_runner.parsing():
                 try:
@@ -238,7 +238,7 @@ def execute_sync(
                     )
 
             if execution_context.operation_type not in allowed_operation_types:
-                raise InvalidOperationTypeError(execution_context.operation_type)
+                raise InvalidOperationTypeError(execution_context.operation_type)  # noqa: TRY301
 
             with extensions_runner.validation():
                 _run_validation(execution_context)
@@ -266,7 +266,7 @@ def execute_sync(
                     if isawaitable(result):
                         result = cast(Awaitable[GraphQLExecutionResult], result)  # type: ignore[redundant-cast]
                         ensure_future(result).cancel()
-                        raise RuntimeError(
+                        raise RuntimeError(  # noqa: TRY301
                             "GraphQL execution failed to complete synchronously."
                         )
 
@@ -282,9 +282,9 @@ def execute_sync(
                         # extension). That way we can log the original errors but
                         # only return a sanitised version to the client.
                         process_errors(result.errors, execution_context)
-    except (MissingQueryError, InvalidOperationTypeError) as e:
-        raise e
-    except Exception as exc:
+    except (MissingQueryError, InvalidOperationTypeError):
+        raise
+    except Exception as exc:  # noqa: BLE001
         errors = [_coerce_error(exc)]
         execution_context.errors = errors
         process_errors(errors, execution_context)

strawberry/schema/name_converter.py

@@ -47,18 +47,17 @@ class NameConverter:
             return self.from_directive(type_)
         if isinstance(type_, EnumDefinition):  # TODO: Replace with StrawberryEnum
             return self.from_enum(type_)
-        elif isinstance(type_, StrawberryObjectDefinition):
+        if isinstance(type_, StrawberryObjectDefinition):
             if type_.is_input:
                 return self.from_input_object(type_)
             if type_.is_interface:
                 return self.from_interface(type_)
             return self.from_object(type_)
-        elif isinstance(type_, StrawberryUnion):
+        if isinstance(type_, StrawberryUnion):
             return self.from_union(type_)
-        elif isinstance(type_, ScalarDefinition):  # TODO: Replace with StrawberryScalar
+        if isinstance(type_, ScalarDefinition):  # TODO: Replace with StrawberryScalar
             return self.from_scalar(type_)
-        else:
-            return str(type_)
+        return str(type_)
 
     def from_argument(self, argument: StrawberryArgument) -> str:
         return self.get_graphql_name(argument)

strawberry/schema/schema.py

@@ -30,6 +30,7 @@ from strawberry.extensions.directives import (
     DirectivesExtensionSync,
 )
 from strawberry.extensions.runner import SchemaExtensionsRunner
+from strawberry.printer import print_schema
 from strawberry.schema.schema_converter import GraphQLCoreConverter
 from strawberry.schema.types.scalar import DEFAULT_SCALAR_REGISTRY
 from strawberry.types import ExecutionContext
@@ -40,7 +41,6 @@ from strawberry.types.base import (
 )
 from strawberry.types.graphql import OperationType
 
-from ..printer import print_schema
 from . import compat
 from .base import BaseSchema
 from .config import StrawberryConfig
@@ -177,9 +177,11 @@ class Schema(BaseSchema):
                     self.schema_converter.from_schema_directive(type_)
                 )
             else:
-                if has_object_definition(type_):
-                    if type_.__strawberry_definition__.is_graphql_generic:
-                        type_ = StrawberryAnnotation(type_).resolve()  # noqa: PLW2901
+                if (
+                    has_object_definition(type_)
+                    and type_.__strawberry_definition__.is_graphql_generic
+                ):
+                    type_ = StrawberryAnnotation(type_).resolve()  # noqa: PLW2901
                 graphql_type = self.schema_converter.from_maybe_optional(type_)
                 if isinstance(graphql_type, GraphQLNonNull):
                     graphql_type = graphql_type.of_type

strawberry/schema/schema_converter.py

@@ -47,6 +47,7 @@ from strawberry.exceptions import (
     ScalarAlreadyRegisteredError,
     UnresolvedFieldTypeError,
 )
+from strawberry.extensions.field_extension import build_field_extension_resolvers
 from strawberry.schema.types.scalar import _make_scalar_type
 from strawberry.types.arguments import StrawberryArgument, convert_arguments
 from strawberry.types.base import (
@@ -57,6 +58,7 @@ from strawberry.types.base import (
     get_object_definition,
     has_object_definition,
 )
+from strawberry.types.cast import get_strawberry_type_cast
 from strawberry.types.enum import EnumDefinition
 from strawberry.types.field import UNRESOLVED
 from strawberry.types.lazy_type import LazyType
@@ -66,7 +68,6 @@ from strawberry.types.union import StrawberryUnion
 from strawberry.types.unset import UNSET
 from strawberry.utils.await_maybe import await_maybe
 
-from ..extensions.field_extension import build_field_extension_resolvers
 from . import compat
 from .types.concrete_type import ConcreteType
 
@@ -91,7 +92,9 @@ if TYPE_CHECKING:
 
 
 FieldType = TypeVar(
-    "FieldType", bound=Union[GraphQLField, GraphQLInputField], covariant=True
+    "FieldType",
+    bound=Union[GraphQLField, GraphQLInputField],
+    covariant=True,
 )
 
 
@@ -374,8 +377,6 @@ class GraphQLCoreConverter:
         # self.from_resolver needs to be called before accessing field.type because
         # in there a field extension might want to change the type during its apply
         resolver = self.from_resolver(field)
-        # TODO: think more about this
-        field._resolver = resolver  # type: ignore
         field_type = cast(
             "GraphQLOutputType",
             self.from_maybe_optional(
@@ -619,6 +620,9 @@ class GraphQLCoreConverter:
             )
 
             def is_type_of(obj: Any, _info: GraphQLResolveInfo) -> bool:
+                if (type_cast := get_strawberry_type_cast(obj)) is not None:
+                    return type_cast in possible_types
+
                 if object_type.concrete_of and (
                     has_object_definition(obj)
                     and obj.__strawberry_definition__.origin
@@ -758,9 +762,8 @@ class GraphQLCoreConverter:
         if field.is_async:
             _async_resolver._is_default = not field.base_resolver  # type: ignore
             return _async_resolver
-        else:
-            _resolver._is_default = not field.base_resolver  # type: ignore
-            return _resolver
+        _resolver._is_default = not field.base_resolver  # type: ignore
+        return _resolver
 
     def from_scalar(self, scalar: type) -> GraphQLScalarType:
         scalar_definition: ScalarDefinition
@@ -810,10 +813,9 @@ class GraphQLCoreConverter:
         NoneType = type(None)
         if type_ is None or type_ is NoneType:
             return self.from_type(type_)
-        elif isinstance(type_, StrawberryOptional):
+        if isinstance(type_, StrawberryOptional):
             return self.from_type(type_.of_type)
-        else:
-            return GraphQLNonNull(self.from_type(type_))
+        return GraphQLNonNull(self.from_type(type_))
 
     def from_type(self, type_: Union[StrawberryType, type]) -> GraphQLNullableType:
         if compat.is_graphql_generic(type_):
@@ -821,27 +823,27 @@ class GraphQLCoreConverter:
 
         if isinstance(type_, EnumDefinition):  # TODO: Replace with StrawberryEnum
             return self.from_enum(type_)
-        elif compat.is_input_type(type_):  # TODO: Replace with StrawberryInputObject
+        if compat.is_input_type(type_):  # TODO: Replace with StrawberryInputObject
             return self.from_input_object(type_)
-        elif isinstance(type_, StrawberryList):
+        if isinstance(type_, StrawberryList):
             return self.from_list(type_)
-        elif compat.is_interface_type(type_):  # TODO: Replace with StrawberryInterface
+        if compat.is_interface_type(type_):  # TODO: Replace with StrawberryInterface
             type_definition: StrawberryObjectDefinition = (
                 type_.__strawberry_definition__  # type: ignore
             )
             return self.from_interface(type_definition)
-        elif has_object_definition(type_):
+        if has_object_definition(type_):
             return self.from_object(type_.__strawberry_definition__)
-        elif compat.is_enum(type_):  # TODO: Replace with StrawberryEnum
+        if compat.is_enum(type_):  # TODO: Replace with StrawberryEnum
             enum_definition: EnumDefinition = type_._enum_definition  # type: ignore
             return self.from_enum(enum_definition)
-        elif isinstance(type_, StrawberryObjectDefinition):
+        if isinstance(type_, StrawberryObjectDefinition):
             return self.from_object(type_)
-        elif isinstance(type_, StrawberryUnion):
+        if isinstance(type_, StrawberryUnion):
             return self.from_union(type_)
-        elif isinstance(type_, LazyType):
+        if isinstance(type_, LazyType):
             return self.from_type(type_.resolve_type())
-        elif compat.is_scalar(
+        if compat.is_scalar(
             type_, self.scalar_registry
         ):  # TODO: Replace with StrawberryScalar
             return self.from_scalar(type_)
@@ -900,6 +902,9 @@ class GraphQLCoreConverter:
         if object_type.interfaces:
 
             def is_type_of(obj: Any, _info: GraphQLResolveInfo) -> bool:
+                if (type_cast := get_strawberry_type_cast(obj)) is not None:
+                    return type_cast is object_type.origin
+
                 if object_type.concrete_of and (
                     has_object_definition(obj)
                     and obj.__strawberry_definition__.origin

strawberry/schema/subscribe.py

@@ -27,7 +27,7 @@ if TYPE_CHECKING:
     from graphql.execution.middleware import MiddlewareManager
     from graphql.type.schema import GraphQLSchema
 
-    from ..extensions.runner import SchemaExtensionsRunner
+    from strawberry.extensions.runner import SchemaExtensionsRunner
 
 SubscriptionResult: TypeAlias = Union[
     PreExecutionError, AsyncGenerator[ExecutionResult, None]
@@ -80,7 +80,7 @@ async def _subscribe(
                     )
                 # graphql-core 3.2 doesn't handle some of the pre-execution errors.
                 # see `test_subscription_immediate_error`
-                except Exception as exc:
+                except Exception as exc:  # noqa: BLE001
                     aiter_or_result = OriginalExecutionResult(
                         data=None, errors=[_coerce_error(exc)]
                     )
@@ -103,7 +103,7 @@ async def _subscribe(
                             process_errors,
                         )
                 # graphql-core doesn't handle exceptions raised while executing.
-                except Exception as exc:
+                except Exception as exc:  # noqa: BLE001
                     yield await _handle_execution_result(
                         execution_context,
                         OriginalExecutionResult(data=None, errors=[_coerce_error(exc)]),
@@ -111,7 +111,7 @@ async def _subscribe(
                         process_errors,
                     )
         # catch exceptions raised in `on_execute` hook.
-        except Exception as exc:
+        except Exception as exc:  # noqa: BLE001
             origin_result = OriginalExecutionResult(
                 data=None, errors=[_coerce_error(exc)]
             )

strawberry/schema/types/base_scalars.py

@@ -15,7 +15,9 @@ def wrap_parser(parser: Callable, type_: str) -> Callable:
         try:
             return parser(value)
         except ValueError as e:
-            raise GraphQLError(f'Value cannot represent a {type_}: "{value}". {e}')
+            raise GraphQLError(  # noqa: B904
+                f'Value cannot represent a {type_}: "{value}". {e}'
+            )
 
     return inner
 
@@ -24,7 +26,7 @@ def parse_decimal(value: object) -> decimal.Decimal:
     try:
         return decimal.Decimal(str(value))
     except decimal.DecimalException:
-        raise GraphQLError(f'Value cannot represent a Decimal: "{value}".')
+        raise GraphQLError(f'Value cannot represent a Decimal: "{value}".')  # noqa: B904
 
 
 isoformat = methodcaller("isoformat")

strawberry/schema/types/scalar.py

@@ -62,7 +62,7 @@ DEFAULT_SCALAR_REGISTRY: dict[object, ScalarDefinition] = {
     datetime.datetime: _get_scalar_definition(base_scalars.DateTime),
     datetime.time: _get_scalar_definition(base_scalars.Time),
     decimal.Decimal: _get_scalar_definition(base_scalars.Decimal),
-    # We can't wrap GLobalID with @scalar because it has custom attributes/methods
+    # We can't wrap GlobalID with @scalar because it has custom attributes/methods
     GlobalID: _get_scalar_definition(
         scalar(
             GlobalID,

strawberry/schema_codegen/__init__.py

@@ -115,7 +115,7 @@ def _get_field_type(
 
     if isinstance(field_type, NonNullTypeNode):
         return _get_field_type(field_type.type, was_non_nullable=True)
-    elif isinstance(field_type, ListTypeNode):
+    if isinstance(field_type, ListTypeNode):
         expr = cst.Subscript(
             value=cst.Name("list"),
             slice=[
@@ -262,14 +262,13 @@ ArgumentValue: TypeAlias = Union[str, bool, list["ArgumentValue"]]
 def _get_argument_value(argument_value: ConstValueNode) -> ArgumentValue:
     if isinstance(argument_value, StringValueNode):
         return argument_value.value
-    elif isinstance(argument_value, EnumValueDefinitionNode):
+    if isinstance(argument_value, EnumValueDefinitionNode):
         return argument_value.name.value
-    elif isinstance(argument_value, ListValueNode):
+    if isinstance(argument_value, ListValueNode):
         return [_get_argument_value(arg) for arg in argument_value.values]
-    elif isinstance(argument_value, BooleanValueNode):
+    if isinstance(argument_value, BooleanValueNode):
         return argument_value.value
-    else:
-        raise NotImplementedError(f"Unknown argument value {argument_value}")
+    raise NotImplementedError(f"Unknown argument value {argument_value}")
 
 
 def _get_directives(

strawberry/subscriptions/protocols/graphql_transport_ws/handlers.py

@@ -122,7 +122,7 @@ class BaseGraphQLTransportWSHandler(Generic[Context, RootValue]):
             self.connection_timed_out = True
             reason = "Connection initialisation timeout"
             await self.websocket.close(code=4408, reason=reason)
-        except Exception as error:
+        except Exception as error:  # noqa: BLE001
             await self.handle_task_exception(error)  # pragma: no cover
         finally:
             # do not clear self.connection_init_timeout_task
@@ -298,7 +298,7 @@ class BaseGraphQLTransportWSHandler(Generic[Context, RootValue]):
                     {"id": operation.id, "type": "complete"}
                 )
 
-        except BaseException as e:  # pragma: no cover
+        except BaseException:  # pragma: no cover
             self.operations.pop(operation.id, None)
             raise
         finally:

strawberry/subscriptions/protocols/graphql_ws/handlers.py

@@ -34,9 +34,6 @@ if TYPE_CHECKING:
 
 
 class BaseGraphQLWSHandler(Generic[Context, RootValue]):
-    context: Context
-    root_value: RootValue
-
     def __init__(
         self,
         view: AsyncBaseHTTPView[Any, Any, Any, Any, Any, Context, RootValue],

strawberry/test/client.py

@@ -188,8 +188,7 @@ class BaseGraphQLTestClient(ABC):
         # Variables can be mixed files and other data, we don't want to map non-files
         # vars so we need to remove them, we can't remove them before
         # because they can be part of a list of files or folder
-        map_without_vars = {k: v for k, v in map.items() if k in files}
-        return map_without_vars
+        return {k: v for k, v in map.items() if k in files}
 
     def _decode(self, response: Any, type: Literal["multipart", "json"]) -> Any:
         if type == "multipart":

strawberry/types/arguments.py

@@ -23,8 +23,8 @@ from strawberry.types.base import (
 )
 from strawberry.types.enum import EnumDefinition
 from strawberry.types.lazy_type import LazyType, StrawberryLazyReference
-from strawberry.types.unset import UNSET as _deprecated_UNSET
-from strawberry.types.unset import _deprecated_is_unset  # noqa # type: ignore
+from strawberry.types.unset import UNSET as _deprecated_UNSET  # noqa: N811
+from strawberry.types.unset import _deprecated_is_unset  # noqa: F401
 
 if TYPE_CHECKING:
     from strawberry.schema.config import StrawberryConfig

strawberry/types/auto.py

@@ -23,8 +23,8 @@ class StrawberryAutoMeta(type):
 
     """
 
-    def __init__(self, *args: str, **kwargs: Any) -> None:
-        self._instance: Optional[StrawberryAuto] = None
+    def __init__(cls, *args: str, **kwargs: Any) -> None:
+        cls._instance: Optional[StrawberryAuto] = None
         super().__init__(*args, **kwargs)
 
     def __call__(cls, *args: str, **kwargs: Any) -> Any:
@@ -34,7 +34,7 @@ class StrawberryAutoMeta(type):
         return cls._instance
 
     def __instancecheck__(
-        self,
+        cls,
         instance: Union[StrawberryAuto, StrawberryAnnotation, StrawberryType, type],
     ) -> bool:
         if isinstance(instance, StrawberryAnnotation):