strawberry-graphql 0.232.1__tar.gz → 0.233.0__tar.gz

{strawberry_graphql-0.232.1 → strawberry_graphql-0.233.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.232.1
+Version: 0.233.0
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT

{strawberry_graphql-0.232.1 → strawberry_graphql-0.233.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.232.1"
+version = "0.233.0"
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "MIT"
@@ -241,7 +241,6 @@ ignore = [
     "ANN101", # missing annotation for self?
     # definitely enable these, maybe not in tests
     "ANN102",
-    "ANN202",
     "ANN401",
     "PGH003",
     "PGH004",

{strawberry_graphql-0.232.1 → strawberry_graphql-0.233.0}/strawberry/custom_scalar.py

@@ -10,7 +10,6 @@ from typing import (
     Mapping,
     NewType,
     Optional,
-    Type,
     TypeVar,
     Union,
     overload,
@@ -85,7 +84,7 @@ class ScalarWrapper:
 
 
 def _process_scalar(
-    cls: Type[_T],
+    cls: _T,
     *,
     name: Optional[str] = None,
     description: Optional[str] = None,
@@ -94,10 +93,10 @@ def _process_scalar(
     parse_value: Optional[Callable] = None,
     parse_literal: Optional[Callable] = None,
     directives: Iterable[object] = (),
-):
+) -> ScalarWrapper:
     from strawberry.exceptions.handler import should_use_rich_exceptions
 
-    name = name or to_camel_case(cls.__name__)
+    name = name or to_camel_case(cls.__name__)  # type: ignore[union-attr]
 
     _source_file = None
     _source_line = None
@@ -155,7 +154,7 @@ def scalar(
 # here or else it won't let us use any custom scalar to annotate attributes in
 # dataclasses/types. This should be properly solved when implementing StrawberryScalar
 def scalar(
-    cls=None,
+    cls: Optional[_T] = None,
     *,
     name: Optional[str] = None,
     description: Optional[str] = None,
@@ -194,7 +193,7 @@ def scalar(
     if parse_value is None:
         parse_value = cls
 
-    def wrap(cls: Type):
+    def wrap(cls: _T) -> ScalarWrapper:
         return _process_scalar(
             cls,
             name=name,

{strawberry_graphql-0.232.1 → strawberry_graphql-0.233.0}/strawberry/experimental/pydantic/conversion.py

@@ -21,7 +21,7 @@ def _convert_from_pydantic_to_strawberry_type(
     type_: Union[StrawberryType, type],
     data_from_model=None,  # noqa: ANN001
     extra=None,  # noqa: ANN001
-):
+) -> Any:
     data = data_from_model if data_from_model is not None else extra
 
     if isinstance(type_, StrawberryOptional):

{strawberry_graphql-0.232.1 → strawberry_graphql-0.233.0}/strawberry/fastapi/router.py

@@ -291,11 +291,11 @@ class GraphQLRouter(
             websocket: WebSocket,
             context: Context = Depends(self.context_getter),
             root_value: RootValue = Depends(self.root_value_getter),
-        ):
-            async def _get_context():
+        ) -> None:
+            async def _get_context() -> Context:
                 return context
 
-            async def _get_root_value():
+            async def _get_root_value() -> RootValue:
                 return root_value
 
             preferred_protocol = self.pick_preferred_protocol(websocket)

{strawberry_graphql-0.232.1 → strawberry_graphql-0.233.0}/strawberry/federation/scalar.py

@@ -6,13 +6,12 @@ from typing import (
     List,
     NewType,
     Optional,
-    Type,
     TypeVar,
     Union,
     overload,
 )
 
-from strawberry.custom_scalar import _process_scalar
+from strawberry.custom_scalar import ScalarWrapper, _process_scalar
 
 # in python 3.10+ NewType is a class
 if sys.version_info >= (3, 10):
@@ -63,7 +62,7 @@ def scalar(
 
 
 def scalar(
-    cls=None,
+    cls: Optional[_T] = None,
     *,
     name: Optional[str] = None,
     description: Optional[str] = None,
@@ -131,7 +130,7 @@ def scalar(
     if tags:
         directives.extend(Tag(name=tag) for tag in tags)
 
-    def wrap(cls: Type):
+    def wrap(cls: _T) -> ScalarWrapper:
         return _process_scalar(
             cls,
             name=name,

{strawberry_graphql-0.232.1 → strawberry_graphql-0.233.0}/strawberry/federation/schema.py

@@ -1,5 +1,4 @@
 from collections import defaultdict
-from copy import copy
 from functools import cached_property, partial
 from itertools import chain
 from typing import (
@@ -10,6 +9,7 @@ from typing import (
     Iterable,
     List,
     Mapping,
+    NewType,
     Optional,
     Set,
     Type,
@@ -17,36 +17,36 @@ from typing import (
     cast,
 )
 
-from graphql import (
-    GraphQLError,
-    GraphQLField,
-    GraphQLInterfaceType,
-    GraphQLList,
-    GraphQLNonNull,
-    GraphQLScalarType,
-    GraphQLUnionType,
-)
-from graphql.type.definition import GraphQLArgument
+from graphql import GraphQLError
 
+from strawberry.annotation import StrawberryAnnotation
+from strawberry.custom_scalar import scalar
 from strawberry.printer import print_schema
 from strawberry.schema import Schema as BaseSchema
+from strawberry.type import (
+    StrawberryContainer,
+    WithStrawberryObjectDefinition,
+    get_object_definition,
+)
+from strawberry.types.info import Info
 from strawberry.types.types import StrawberryObjectDefinition
+from strawberry.union import StrawberryUnion
 from strawberry.utils.inspect import get_func_args
 
 from .schema_directive import StrawberryFederationSchemaDirective
 
 if TYPE_CHECKING:
     from graphql import ExecutionContext as GraphQLExecutionContext
-    from graphql import GraphQLObjectType
 
     from strawberry.custom_scalar import ScalarDefinition, ScalarWrapper
     from strawberry.enum import EnumDefinition
     from strawberry.extensions import SchemaExtension
     from strawberry.federation.schema_directives import ComposeDirective
     from strawberry.schema.config import StrawberryConfig
-    from strawberry.schema.types.concrete_type import TypeMap
     from strawberry.schema_directive import StrawberrySchemaDirective
-    from strawberry.union import StrawberryUnion
+
+
+FederationAny = scalar(NewType("_Any", object), name="_Any")  # type: ignore
 
 
 class Schema(BaseSchema):
@@ -67,7 +67,8 @@ class Schema(BaseSchema):
         schema_directives: Iterable[object] = (),
         enable_federation_2: bool = False,
     ) -> None:
-        query = self._get_federation_query_type(query)
+        query = self._get_federation_query_type(query, mutation, subscription, types)
+        types = [*types, FederationAny]
 
         super().__init__(
             query=query,
@@ -84,16 +85,19 @@ class Schema(BaseSchema):
 
         self.schema_directives = list(schema_directives)
 
-        self._add_scalars()
-        self._add_entities_to_query()
-
         if enable_federation_2:
             composed_directives = self._add_compose_directives()
             self._add_link_directives(composed_directives)  # type: ignore
         else:
             self._remove_resolvable_field()
 
-    def _get_federation_query_type(self, query: Optional[Type]) -> Type:
+    def _get_federation_query_type(
+        self,
+        query: Optional[Type[WithStrawberryObjectDefinition]],
+        mutation: Optional[Type[WithStrawberryObjectDefinition]],
+        subscription: Optional[Type[WithStrawberryObjectDefinition]],
+        additional_types: Iterable[Type[WithStrawberryObjectDefinition]],
+    ) -> Type:
         """Returns a new query type that includes the _service field.
 
         If the query type is provided, it will be used as the base for the new
@@ -109,13 +113,6 @@ class Schema(BaseSchema):
         added if the schema contains an entity type.
         """
 
-        # note we don't add the _entities field here, as we need to know if the
-        # schema contains an entity type first and we do that by leveraging
-        # the schema converter type map, so we don't have to do that twice
-        # TODO: ideally we should be able to do this without using the schema
-        # converter, but for now this is the easiest way to do it
-        # see `_add_entities_to_query`
-
         import strawberry
         from strawberry.tools.create_type import create_type
         from strawberry.tools.merge_types import merge_types
@@ -132,6 +129,19 @@ class Schema(BaseSchema):
 
         fields = [service]
 
+        entity_type = _get_entity_type(query, mutation, subscription, additional_types)
+
+        if entity_type:
+            self.entities_resolver.__annotations__["return"] = List[
+                Optional[entity_type]  # type: ignore
+            ]
+
+            entities_field = strawberry.field(
+                name="_entities", resolver=self.entities_resolver
+            )
+
+            fields.insert(0, entities_field)
+
         FederationQuery = create_type(name="Query", fields=fields)
 
         if query is None:
@@ -139,10 +149,7 @@ class Schema(BaseSchema):
 
         query_type = merge_types(
             "Query",
-            (
-                FederationQuery,
-                query,
-            ),
+            (FederationQuery, query),
         )
 
         # TODO: this should be probably done in merge_types
@@ -151,31 +158,9 @@ class Schema(BaseSchema):
 
         return query_type
 
-    def _add_entities_to_query(self):
-        entity_type = _get_entity_type(self.schema_converter.type_map)
-
-        if not entity_type:
-            return
-
-        self._schema.type_map[entity_type.name] = entity_type
-        fields = {"_entities": self._get_entities_field(entity_type)}
-
-        # Copy the query type, update it to use the modified fields
-        query_type = cast("GraphQLObjectType", self._schema.query_type)
-        fields.update(query_type.fields)
-
-        query_type = copy(query_type)
-        query_type.fields = fields
-
-        self._schema.query_type = query_type
-        self._schema.type_map[query_type.name] = query_type
-
     def entities_resolver(
-        self,
-        root,  # noqa: ANN001
-        info,  # noqa: ANN001
-        representations,  # noqa: ANN001
-    ) -> List[object]:
+        self, info: Info, representations: List[FederationAny]
+    ) -> List[FederationAny]:
         results = []
 
         for representation in representations:
@@ -198,9 +183,8 @@ class Schema(BaseSchema):
             else:
                 from strawberry.arguments import convert_argument
 
-                strawberry_schema = info.schema.extensions["strawberry-definition"]
-                config = strawberry_schema.config
-                scalar_registry = strawberry_schema.schema_converter.scalar_registry
+                config = info.schema.config
+                scalar_registry = info.schema.schema_converter.scalar_registry
 
                 get_result = partial(
                     convert_argument,
@@ -222,11 +206,6 @@ class Schema(BaseSchema):
 
         return results
 
-    def _add_scalars(self):
-        self.Any = GraphQLScalarType("_Any")
-
-        self._schema.type_map["_Any"] = self.Any
-
     def _remove_resolvable_field(self) -> None:
         # this might be removed when we remove support for federation 1
         # or when we improve how we print the directives
@@ -283,7 +262,7 @@ class Schema(BaseSchema):
 
     def _add_link_directives(
         self, additional_directives: Optional[List[object]] = None
-    ):
+    ) -> None:
         from .schema_directives import FederationDirective, Link
 
         directive_by_url: DefaultDict[str, Set[str]] = defaultdict(set)
@@ -335,17 +314,6 @@ class Schema(BaseSchema):
 
         return compose_directives
 
-    def _get_entities_field(self, entity_type: GraphQLUnionType) -> GraphQLField:
-        return GraphQLField(
-            GraphQLNonNull(GraphQLList(entity_type)),
-            args={
-                "representations": GraphQLArgument(
-                    GraphQLNonNull(GraphQLList(GraphQLNonNull(self.Any)))
-                )
-            },
-            resolve=self.entities_resolver,
-        )
-
     def _warn_for_federation_directives(self) -> None:
         # this is used in the main schema to raise if there's a directive
         # that's for federation, but in this class we don't want to warn,
@@ -354,33 +322,56 @@ class Schema(BaseSchema):
         pass
 
 
-def _get_entity_type(type_map: "TypeMap"):
-    # https://www.apollographql.com/docs/apollo-server/federation/federation-spec/#resolve-requests-for-entities
+def _get_entity_type(
+    query: Optional[Type[WithStrawberryObjectDefinition]],
+    mutation: Optional[Type[WithStrawberryObjectDefinition]],
+    subscription: Optional[Type[WithStrawberryObjectDefinition]],
+    additional_types: Iterable[Type[WithStrawberryObjectDefinition]],
+) -> Optional[StrawberryUnion]:
+    # recursively iterate over the schema to find all types annotated with @key
+    # if no types are annotated with @key, then the _Entity union and Query._entities
+    # field should not be added to the schema
 
-    # To implement the _Entity union, each type annotated with @key
-    # should be added to the _Entity union.
+    entity_types = set()
 
-    federation_key_types = [
-        type.implementation
-        for type in type_map.values()
-        if _has_federation_keys(type.definition)
-        # TODO: check this
-        and not isinstance(type.implementation, GraphQLInterfaceType)
-    ]
+    # need a stack to keep track of the types we need to visit
+    stack: List[Any] = [query, mutation, subscription, *additional_types]
 
-    # If no types are annotated with the key directive, then the _Entity
-    # union and Query._entities field should be removed from the schema.
-    if not federation_key_types:
-        return None
+    seen = set()
 
-    entity_type = GraphQLUnionType("_Entity", federation_key_types)  # type: ignore
+    while stack:
+        type_ = stack.pop()
 
-    def _resolve_type(self, value, _type):  # noqa: ANN001
-        return self.__strawberry_definition__.name
+        if type_ is None:
+            continue
+
+        while isinstance(type_, StrawberryContainer):
+            type_ = type_.of_type
+
+        type_definition = get_object_definition(type_, strict=False)
+
+        if type_definition is None:
+            continue
+
+        if type_definition.is_object_type and _has_federation_keys(type_definition):
+            entity_types.add(type_)
+
+        for field in type_definition.fields:
+            if field.type and field.type in seen:
+                continue
+
+            seen.add(field.type)
+            stack.append(field.type)
+
+    if not entity_types:
+        return None
 
-    entity_type.resolve_type = _resolve_type
+    sorted_types = sorted(entity_types, key=lambda t: t.__strawberry_definition__.name)
 
-    return entity_type
+    return StrawberryUnion(
+        "_Entity",
+        type_annotations=tuple(StrawberryAnnotation(type_) for type_ in sorted_types),
+    )
 
 
 def _is_key(directive: Any) -> bool:

{strawberry_graphql-0.232.1 → strawberry_graphql-0.233.0}/strawberry/federation/schema_directive.py

@@ -38,7 +38,7 @@ def schema_directive(
     import_url: Optional[str] = None,
 ) -> Callable[..., T]:
     def _wrap(cls: T) -> T:
-        cls = _wrap_dataclass(cls)
+        cls = _wrap_dataclass(cls)  # type: ignore
         fields = _get_fields(cls, {})
 
         cls.__strawberry_directive__ = StrawberryFederationSchemaDirective(

{strawberry_graphql-0.232.1 → strawberry_graphql-0.233.0}/strawberry/object_type.py

@@ -44,7 +44,7 @@ def _get_interfaces(cls: Type[Any]) -> List[StrawberryObjectDefinition]:
     return interfaces
 
 
-def _check_field_annotations(cls: Type[Any]):
+def _check_field_annotations(cls: Type[Any]) -> None:
     """Are any of the dataclass Fields missing type annotations?
 
     This is similar to the check that dataclasses do during creation, but allows us to
@@ -102,7 +102,7 @@ def _check_field_annotations(cls: Type[Any]):
             raise MissingFieldAnnotationError(field_name, cls)
 
 
-def _wrap_dataclass(cls: Type[Any]):
+def _wrap_dataclass(cls: Type[T]) -> Type[T]:
     """Wrap a strawberry.type class with a dataclass and check for any issues
     before doing so"""
 
@@ -239,7 +239,7 @@ def type(
     >>>     field_abc: str = "ABC"
     """
 
-    def wrap(cls: Type) -> T:
+    def wrap(cls: T) -> T:
         if not inspect.isclass(cls):
             if is_input:
                 exc = ObjectIsNotClassError.input
@@ -268,7 +268,7 @@ def type(
 
         wrapped = _wrap_dataclass(cls)
 
-        return _process_type(
+        return _process_type(  # type: ignore
             wrapped,
             name=name,
             is_input=is_input,

{strawberry_graphql-0.232.1 → strawberry_graphql-0.233.0}/strawberry/printer/printer.py

@@ -566,7 +566,7 @@ def print_schema(schema: BaseSchema) -> str:
         None, [print_directive(directive, schema=schema) for directive in directives]
     )
 
-    def _name_getter(type_: Any):
+    def _name_getter(type_: Any) -> str:
         if hasattr(type_, "name"):
             return type_.name
         if isinstance(type_, ScalarWrapper):

{strawberry_graphql-0.232.1 → strawberry_graphql-0.233.0}/strawberry/relay/fields.py

@@ -9,6 +9,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     AsyncIterator,
+    Awaitable,
     Callable,
     DefaultDict,
     Dict,
@@ -35,6 +36,7 @@ from strawberry.extensions.field_extension import (
     SyncExtensionResolver,
 )
 from strawberry.field import _RESOLVER_TYPE, StrawberryField, field
+from strawberry.lazy_type import LazyType
 from strawberry.relay.exceptions import (
     RelayWrongAnnotationError,
     RelayWrongResolverAnnotationError,
@@ -42,7 +44,7 @@ from strawberry.relay.exceptions import (
 from strawberry.type import StrawberryList, StrawberryOptional
 from strawberry.types.fields.resolver import StrawberryResolver
 from strawberry.utils.aio import asyncgen_to_list
-from strawberry.utils.typing import eval_type
+from strawberry.utils.typing import eval_type, is_generic_alias
 
 from .types import Connection, GlobalID, Node, NodeIterableType, NodeType
 
@@ -86,7 +88,7 @@ class NodeExtension(FieldExtension):
         def resolver(
             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(
                 id.node_id,
                 info=info,
@@ -105,7 +107,7 @@ class NodeExtension(FieldExtension):
             ids: Annotated[
                 List[GlobalID], argument(description="The IDs of the objects.")
             ],
-        ):
+        ) -> Union[List[Node], Awaitable[List[Node]]]:
             nodes_map: DefaultDict[Type[Node], List[str]] = defaultdict(list)
             # Store the index of the node in the list of nodes of the same type
             # so that we can return them in the same order while also supporting
@@ -138,7 +140,7 @@ class NodeExtension(FieldExtension):
 
             if awaitable_nodes or asyncgen_nodes:
 
-                async def resolve(resolved=resolved_nodes):  # noqa: ANN001
+                async def resolve(resolved: Any = resolved_nodes) -> List[Node]:
                     resolved.update(
                         zip(
                             [
@@ -222,7 +224,13 @@ class ConnectionExtension(FieldExtension):
         ]
 
         f_type = field.type
-        if not isinstance(f_type, type) or not issubclass(f_type, Connection):
+
+        if isinstance(f_type, LazyType):
+            f_type = f_type.resolve_type()
+            field.type = f_type
+
+        type_origin = get_origin(f_type) if is_generic_alias(f_type) else f_type
+        if not isinstance(type_origin, type) or not issubclass(type_origin, Connection):
             raise RelayWrongAnnotationError(field.name, cast(type, field.origin))
 
         assert field.base_resolver

{strawberry_graphql-0.232.1 → strawberry_graphql-0.233.0}/strawberry/relay/types.py

@@ -859,7 +859,7 @@ class ListConnection(Connection[NodeType]):
 
         if isinstance(nodes, (AsyncIterator, AsyncIterable)) and in_async_context():
 
-            async def resolver():
+            async def resolver() -> Self:
                 try:
                     iterator = cast(
                         Union[AsyncIterator[NodeType], AsyncIterable[NodeType]],

{strawberry_graphql-0.232.1 → strawberry_graphql-0.233.0}/strawberry/schema/schema.py

@@ -324,7 +324,7 @@ class Schema(BaseSchema):
             operation_name=operation_name,
         )
 
-    def _resolve_node_ids(self):
+    def _resolve_node_ids(self) -> None:
         for concrete_type in self.schema_converter.type_map.values():
             type_def = concrete_type.definition
 
@@ -355,7 +355,7 @@ class Schema(BaseSchema):
                 if not has_custom_resolve_id:
                     origin.resolve_id_attr()
 
-    def _warn_for_federation_directives(self):
+    def _warn_for_federation_directives(self) -> None:
         """Raises a warning if the schema has any federation directives."""
         from strawberry.federation.schema_directives import FederationDirective
 
@@ -378,7 +378,7 @@ class Schema(BaseSchema):
                 stacklevel=3,
             )
 
-    def _extend_introspection(self):
+    def _extend_introspection(self) -> None:
         def _resolve_is_one_of(obj: Any, info: Any) -> bool:
             return obj.extensions["strawberry-definition"].is_one_of
 

{strawberry_graphql-0.232.1 → strawberry_graphql-0.233.0}/strawberry/schema/schema_converter.py

@@ -462,7 +462,12 @@ class GraphQLCoreConverter:
             assert isinstance(graphql_interface, GraphQLInterfaceType)  # For mypy
             return graphql_interface
 
-        def _get_resolve_type():
+        def _get_resolve_type() -> (
+            Callable[
+                [Any, GraphQLResolveInfo, GraphQLAbstractType],
+                Union[Awaitable[Optional[str]], str, None],
+            ]
+        ):
             if interface.resolve_type:
                 return interface.resolve_type
 
@@ -594,7 +599,7 @@ class GraphQLCoreConverter:
 
         if field.is_basic_field:
 
-            def _get_basic_result(_source: Any, *args: str, **kwargs: Any):
+            def _get_basic_result(_source: Any, *args: str, **kwargs: Any) -> Any:
                 # Call `get_result` without an info object or any args or
                 # kwargs because this is a basic field with no resolver.
                 return field.get_result(_source, info=None, args=[], kwargs={})
@@ -664,7 +669,7 @@ class GraphQLCoreConverter:
             info: Info,
             field_args: List[Any],
             field_kwargs: Dict[str, Any],
-        ):
+        ) -> Any:
             return field.get_result(
                 _source, info=info, args=field_args, kwargs=field_kwargs
             )
@@ -681,7 +686,7 @@ class GraphQLCoreConverter:
                 _source: Any,
                 info: Info,
                 **kwargs: Any,
-            ):
+            ) -> Any:
                 # parse field arguments into Strawberry input types and convert
                 # field names to Python equivalents
                 field_args, field_kwargs = _get_arguments(
@@ -698,7 +703,7 @@ class GraphQLCoreConverter:
                 # `_get_result` expects `field_args` and `field_kwargs` as
                 # separate arguments so we have to wrap the function so that we
                 # can pass them in
-                def wrapped_get_result(_source: Any, info: Info, **kwargs: Any):
+                def wrapped_get_result(_source: Any, info: Info, **kwargs: Any) -> Any:
                     # if the resolver function requested the info object info
                     # then put it back in the kwargs dictionary
                     if resolver_requested_info:
@@ -719,7 +724,7 @@ class GraphQLCoreConverter:
 
         _get_result_with_extensions = wrap_field_extensions()
 
-        def _resolver(_source: Any, info: GraphQLResolveInfo, **kwargs: Any):
+        def _resolver(_source: Any, info: GraphQLResolveInfo, **kwargs: Any) -> Any:
             strawberry_info = _strawberry_info_from_graphql(info)
 
             return _get_result_with_extensions(
@@ -730,7 +735,7 @@ class GraphQLCoreConverter:
 
         async def _async_resolver(
             _source: Any, info: GraphQLResolveInfo, **kwargs: Any
-        ):
+        ) -> Any:
             strawberry_info = _strawberry_info_from_graphql(info)
 
             return await await_maybe(

{strawberry_graphql-0.232.1 → strawberry_graphql-0.233.0}/strawberry/schema/types/base_scalars.py

@@ -11,7 +11,7 @@ from strawberry.custom_scalar import scalar
 
 
 def wrap_parser(parser: Callable, type_: str) -> Callable:
-    def inner(value: str):
+    def inner(value: str) -> object:
         try:
             return parser(value)
         except ValueError as e:

{strawberry_graphql-0.232.1 → strawberry_graphql-0.233.0}/strawberry/schema_directive.py

@@ -53,7 +53,7 @@ def schema_directive(
     print_definition: bool = True,
 ) -> Callable[..., T]:
     def _wrap(cls: T) -> T:
-        cls = _wrap_dataclass(cls)
+        cls = _wrap_dataclass(cls)  # type: ignore
         fields = _get_fields(cls, {})
 
         cls.__strawberry_directive__ = StrawberrySchemaDirective(