strawberry-graphql 0.263.0.dev1743582446__py3-none-any.whl → 0.263.2__py3-none-any.whl

strawberry/printer/printer.py

@@ -151,7 +151,7 @@ def print_schema_directive(
     directive: Any, schema: BaseSchema, *, extras: PrintExtras
 ) -> str:
     strawberry_directive = cast(
-        StrawberrySchemaDirective, directive.__class__.__strawberry_directive__
+        "StrawberrySchemaDirective", directive.__class__.__strawberry_directive__
     )
     schema_converter = schema.schema_converter
     gql_directive = schema_converter.from_schema_directive(directive.__class__)
@@ -178,13 +178,13 @@ def print_schema_directive(
                 f_type = f_type.of_type
 
             if has_object_definition(f_type):
-                extras.types.add(cast(type, f_type))
+                extras.types.add(cast("type", f_type))
 
             if hasattr(f_type, "_scalar_definition"):
-                extras.types.add(cast(type, f_type))
+                extras.types.add(cast("type", f_type))
 
             if isinstance(f_type, EnumDefinition):
-                extras.types.add(cast(type, f_type))
+                extras.types.add(cast("type", f_type))
 
     return f" @{gql_directive.name}{params}"
 
@@ -363,7 +363,7 @@ def print_extends(type_: GraphQLObjectType, schema: BaseSchema) -> str:
     from strawberry.schema.schema_converter import GraphQLCoreConverter
 
     strawberry_type = cast(
-        Optional[StrawberryObjectDefinition],
+        "Optional[StrawberryObjectDefinition]",
         type_.extensions
         and type_.extensions.get(GraphQLCoreConverter.DEFINITION_BACKREF),
     )
@@ -380,7 +380,7 @@ def print_type_directives(
     from strawberry.schema.schema_converter import GraphQLCoreConverter
 
     strawberry_type = cast(
-        Optional[StrawberryObjectDefinition],
+        "Optional[StrawberryObjectDefinition]",
         type_.extensions
         and type_.extensions.get(GraphQLCoreConverter.DEFINITION_BACKREF),
     )
@@ -561,9 +561,9 @@ def print_schema_definition(
 def print_directive(
     directive: GraphQLDirective, *, schema: BaseSchema
 ) -> Optional[str]:
-    strawberry_directive = directive.extensions.get("strawberry-definition")
+    strawberry_directive = directive.extensions["strawberry-definition"]
 
-    if strawberry_directive is None or (
+    if (
         isinstance(strawberry_directive, StrawberrySchemaDirective)
         and not strawberry_directive.print_definition
     ):
@@ -594,7 +594,7 @@ def is_builtin_directive(directive: GraphQLDirective) -> bool:
 
 def print_schema(schema: BaseSchema) -> str:
     graphql_core_schema = cast(
-        GraphQLSchema,
+        "GraphQLSchema",
         schema._schema,  # type: ignore
     )
     extras = PrintExtras()

strawberry/quart/views.py

@@ -27,7 +27,7 @@ class QuartHTTPRequestAdapter(AsyncHTTPRequestAdapter):
 
     @property
     def method(self) -> HTTPMethod:
-        return cast(HTTPMethod, self.request.method.upper())
+        return cast("HTTPMethod", self.request.method.upper())
 
     @property
     def content_type(self) -> Optional[str]:

strawberry/relay/exceptions.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from collections.abc import Callable
 from functools import cached_property
 from typing import TYPE_CHECKING, Optional, cast
 
@@ -8,6 +7,8 @@ from strawberry.exceptions.exception import StrawberryException
 from strawberry.exceptions.utils.source_finder import SourceFinder
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from strawberry.exceptions.exception_source import ExceptionSource
     from strawberry.types.fields.resolver import StrawberryResolver
 
@@ -101,7 +102,7 @@ class RelayWrongResolverAnnotationError(StrawberryException):
             return None  # pragma: no cover
 
         source_finder = SourceFinder()
-        return source_finder.find_function_from_object(cast(Callable, self.function))
+        return source_finder.find_function_from_object(cast("Callable", self.function))
 
 
 __all__ = [

strawberry/relay/fields.py

@@ -108,7 +108,7 @@ class NodeExtension(FieldExtension):
 
                 return resolve()
 
-            return cast(Node, strawberry_cast(node_type, resolved_node))
+            return cast("Node", strawberry_cast(node_type, resolved_node))
 
         return resolver
 
@@ -161,7 +161,7 @@ class NodeExtension(FieldExtension):
             # 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]
+                return [cast("Node", strawberry_cast(node_t, node)) for node in nodes]
 
             if awaitable_nodes or asyncgen_nodes:
 
@@ -196,7 +196,7 @@ class NodeExtension(FieldExtension):
 
             # Resolve any generator to lists
             resolved = {
-                node_t: cast_nodes(node_t, cast(Iterable[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]
@@ -264,7 +264,7 @@ class ConnectionExtension(FieldExtension):
         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))
+            raise RelayWrongAnnotationError(field.name, cast("type", field.origin))
 
         assert field.base_resolver
         # TODO: We are not using resolver_type.type because it will call
@@ -294,7 +294,7 @@ class ConnectionExtension(FieldExtension):
         ):
             raise RelayWrongResolverAnnotationError(field.name, field.base_resolver)
 
-        self.connection_type = cast(type[Connection[Node]], f_type)
+        self.connection_type = cast("type[Connection[Node]]", f_type)
 
     def resolve(
         self,
@@ -310,7 +310,7 @@ class ConnectionExtension(FieldExtension):
     ) -> Any:
         assert self.connection_type is not None
         return self.connection_type.resolve_connection(
-            cast(Iterable[Node], next_(source, info, **kwargs)),
+            cast("Iterable[Node]", next_(source, info, **kwargs)),
             info=info,
             before=before,
             after=after,
@@ -339,7 +339,7 @@ class ConnectionExtension(FieldExtension):
             nodes = await nodes
 
         resolved = self.connection_type.resolve_connection(
-            cast(Iterable[Node], nodes),
+            cast("Iterable[Node]", nodes),
             info=info,
             before=before,
             after=after,

strawberry/relay/types.py

@@ -39,7 +39,7 @@ from strawberry.types.lazy_type import LazyType
 from strawberry.types.object_type import interface
 from strawberry.types.object_type import type as strawberry_type
 from strawberry.types.private import StrawberryPrivate
-from strawberry.utils.aio import aenumerate, aislice, resolve_awaitable
+from strawberry.utils.aio import aclosing, aenumerate, aislice, resolve_awaitable
 from strawberry.utils.inspect import in_async_context
 from strawberry.utils.typing import eval_type, is_classvar
 
@@ -188,7 +188,7 @@ class GlobalID:
         """
         n_type = self.resolve_type(info)
         node: Node | Awaitable[Node] = cast(
-            Awaitable[Node],
+            "Awaitable[Node]",
             n_type.resolve_node(
                 self.node_id,
                 info=info,
@@ -393,7 +393,7 @@ class Node:
             parent_type = info._raw_info.parent_type
             type_def = info.schema.get_type_by_name(parent_type.name)
             assert isinstance(type_def, StrawberryObjectDefinition)
-            origin = cast(type[Node], type_def.origin)
+            origin = cast("type[Node]", type_def.origin)
             resolve_id = origin.resolve_id
             resolve_typename = origin.resolve_typename
 
@@ -404,7 +404,7 @@ class Node:
 
         if inspect.isawaitable(node_id):
             return cast(
-                GlobalID,
+                "GlobalID",
                 resolve_awaitable(
                     node_id,
                     lambda resolved: GlobalID(
@@ -617,7 +617,7 @@ class Node:
         if inspect.isawaitable(retval):
             return resolve_awaitable(retval, lambda resolved: next(iter(resolved)))
 
-        return next(iter(cast(Iterable[Self], retval)))
+        return next(iter(cast("Iterable[Self]", retval)))
 
 
 @strawberry_type(description="Information to aid in pagination.")
@@ -810,15 +810,15 @@ class ListConnection(Connection[NodeType]):
         while isinstance(field, StrawberryContainer):
             field = field.of_type
 
-        edge_class = cast(Edge[NodeType], field)
+        edge_class = cast("Edge[NodeType]", field)
 
         if isinstance(nodes, (AsyncIterator, AsyncIterable)) and in_async_context():
 
             async def resolver() -> Self:
                 try:
                     iterator = cast(
-                        Union[AsyncIterator[NodeType], AsyncIterable[NodeType]],
-                        cast(Sequence, nodes)[
+                        "Union[AsyncIterator[NodeType], AsyncIterable[NodeType]]",
+                        cast("Sequence", nodes)[
                             slice_metadata.start : slice_metadata.overfetch
                         ],
                     )
@@ -831,24 +831,25 @@ class ListConnection(Connection[NodeType]):
                         slice_metadata.overfetch,
                     )
 
-                # The slice above might return an object that now is not async
-                # iterable anymore (e.g. an already cached django queryset)
-                if isinstance(iterator, (AsyncIterator, AsyncIterable)):
-                    edges: list[Edge] = [
-                        edge_class.resolve_edge(
-                            cls.resolve_node(v, info=info, **kwargs),
-                            cursor=slice_metadata.start + i,
-                        )
-                        async for i, v in aenumerate(iterator)
-                    ]
-                else:
-                    edges: list[Edge] = [  # type: ignore[no-redef]
-                        edge_class.resolve_edge(
-                            cls.resolve_node(v, info=info, **kwargs),
-                            cursor=slice_metadata.start + i,
-                        )
-                        for i, v in enumerate(iterator)
-                    ]
+                async with aclosing(iterator):
+                    # The slice above might return an object that now is not async
+                    # iterable anymore (e.g. an already cached django queryset)
+                    if isinstance(iterator, (AsyncIterator, AsyncIterable)):
+                        edges: list[Edge] = [
+                            edge_class.resolve_edge(
+                                cls.resolve_node(v, info=info, **kwargs),
+                                cursor=slice_metadata.start + i,
+                            )
+                            async for i, v in aenumerate(iterator)
+                        ]
+                    else:
+                        edges: list[Edge] = [  # type: ignore[no-redef]
+                            edge_class.resolve_edge(
+                                cls.resolve_node(v, info=info, **kwargs),
+                                cursor=slice_metadata.start + i,
+                            )
+                            for i, v in enumerate(iterator)
+                        ]
 
                 has_previous_page = slice_metadata.start > 0
                 if (
@@ -882,8 +883,10 @@ class ListConnection(Connection[NodeType]):
 
         try:
             iterator = cast(
-                Union[Iterator[NodeType], Iterable[NodeType]],
-                cast(Sequence, nodes)[slice_metadata.start : slice_metadata.overfetch],
+                "Union[Iterator[NodeType], Iterable[NodeType]]",
+                cast("Sequence", nodes)[
+                    slice_metadata.start : slice_metadata.overfetch
+                ],
             )
         except TypeError:
             assert isinstance(nodes, (Iterable, Iterator))

strawberry/sanic/utils.py

@@ -3,10 +3,8 @@ from __future__ import annotations
 from io import BytesIO
 from typing import TYPE_CHECKING, Any, Optional, Union, cast
 
-from sanic.request import File
-
 if TYPE_CHECKING:
-    from sanic.request import Request
+    from sanic.request import File, Request
 
 
 def convert_request_to_files_dict(request: Request) -> dict[str, Any]:
@@ -24,7 +22,7 @@ def convert_request_to_files_dict(request: Request) -> dict[str, Any]:
 
     Note that the dictionary entries are lists.
     """
-    request_files = cast(Optional[dict[str, list[File]]], request.files)
+    request_files = cast("Optional[dict[str, list[File]]]", request.files)
 
     if not request_files:
         return {}

strawberry/sanic/views.py

@@ -48,7 +48,7 @@ class SanicHTTPRequestAdapter(AsyncHTTPRequestAdapter):
 
     @property
     def method(self) -> HTTPMethod:
-        return cast(HTTPMethod, self.request.method.upper())
+        return cast("HTTPMethod", self.request.method.upper())
 
     @property
     def headers(self) -> Mapping[str, str]:

strawberry/schema/config.py

@@ -16,7 +16,6 @@ class StrawberryConfig:
     relay_max_results: int = 100
     disable_field_suggestions: bool = False
     info_class: type[Info] = Info
-    enable_experimental_incremental_execution: bool = False
 
     def __post_init__(
         self,

strawberry/schema/schema.py

@@ -29,6 +29,8 @@ from graphql import (
     parse,
     validate_schema,
 )
+from graphql.execution import ExecutionContext as GraphQLExecutionContext
+from graphql.execution import execute, subscribe
 from graphql.execution.middleware import MiddlewareManager
 from graphql.type.directives import specified_directives
 from graphql.validation import validate
@@ -58,18 +60,10 @@ from strawberry.types.execution import (
 )
 from strawberry.types.graphql import OperationType
 from strawberry.utils import IS_GQL_32
+from strawberry.utils.aio import aclosing
 from strawberry.utils.await_maybe import await_maybe
 
 from . import compat
-from ._graphql_core import (
-    GraphQLExecutionContext,
-    GraphQLIncrementalExecutionResults,
-    ResultType,
-    execute,
-    experimental_execute_incrementally,
-    incremental_execution_directives,
-    subscribe,
-)
 from .base import BaseSchema
 from .config import StrawberryConfig
 from .exceptions import InvalidOperationTypeError
@@ -98,7 +92,6 @@ OriginSubscriptionResult = Union[
     AsyncIterator[OriginalExecutionResult],
 ]
 
-
 DEFAULT_ALLOWED_OPERATION_TYPES = {
     OperationType.QUERY,
     OperationType.MUTATION,
@@ -213,7 +206,7 @@ class Schema(BaseSchema):
         scalar_registry: SCALAR_OVERRIDES_DICT_TYPE = {**DEFAULT_SCALAR_REGISTRY}
         if scalar_overrides:
             # TODO: check that the overrides are valid
-            scalar_registry.update(cast(SCALAR_OVERRIDES_DICT_TYPE, scalar_overrides))
+            scalar_registry.update(cast("SCALAR_OVERRIDES_DICT_TYPE", scalar_overrides))
 
         self.schema_converter = GraphQLCoreConverter(
             self.config, scalar_registry, self.get_fields
@@ -222,12 +215,14 @@ class Schema(BaseSchema):
         self.schema_directives = list(schema_directives)
 
         query_type = self.schema_converter.from_object(
-            cast(type[WithStrawberryObjectDefinition], query).__strawberry_definition__
+            cast(
+                "type[WithStrawberryObjectDefinition]", query
+            ).__strawberry_definition__
         )
         mutation_type = (
             self.schema_converter.from_object(
                 cast(
-                    type[WithStrawberryObjectDefinition], mutation
+                    "type[WithStrawberryObjectDefinition]", mutation
                 ).__strawberry_definition__
             )
             if mutation
@@ -236,7 +231,7 @@ class Schema(BaseSchema):
         subscription_type = (
             self.schema_converter.from_object(
                 cast(
-                    type[WithStrawberryObjectDefinition], subscription
+                    "type[WithStrawberryObjectDefinition]", subscription
                 ).__strawberry_definition__
             )
             if subscription
@@ -267,16 +262,11 @@ class Schema(BaseSchema):
                 graphql_types.append(graphql_type)
 
         try:
-            directives = specified_directives + tuple(graphql_directives)
-
-            if self.config.enable_experimental_incremental_execution:
-                directives = tuple(directives) + tuple(incremental_execution_directives)
-
             self._schema = GraphQLSchema(
                 query=query_type,
                 mutation=mutation_type,
                 subscription=subscription_type if subscription else None,
-                directives=directives,
+                directives=specified_directives + tuple(graphql_directives),
                 types=graphql_types,
                 extensions={
                     GraphQLCoreConverter.DEFINITION_BACKREF: self,
@@ -454,16 +444,12 @@ class Schema(BaseSchema):
     async def _handle_execution_result(
         self,
         context: ExecutionContext,
-        result: ResultType,
+        result: Union[GraphQLExecutionResult, ExecutionResult],
         extensions_runner: SchemaExtensionsRunner,
         *,
         # TODO: can we remove this somehow, see comment in execute
         skip_process_errors: bool = False,
     ) -> ExecutionResult:
-        # TODO: handle this, also, why do we have both GraphQLExecutionResult and ExecutionResult?
-        if isinstance(result, GraphQLIncrementalExecutionResults):
-            return result
-
         # Set errors on the context so that it's easier
         # to access in extensions
         if result.errors:
@@ -504,14 +490,6 @@ class Schema(BaseSchema):
         extensions_runner = self.create_extensions_runner(execution_context, extensions)
         middleware_manager = self._get_middleware_manager(extensions)
 
-        execute_function = (
-            experimental_execute_incrementally
-            if self.config.enable_experimental_incremental_execution
-            else execute
-        )
-
-        # TODO: raise if experimental_execute_incrementally is not available
-
         try:
             async with extensions_runner.operation():
                 # Note: In graphql-core the schema would be validated here but in
@@ -530,7 +508,7 @@ class Schema(BaseSchema):
                 async with extensions_runner.executing():
                     if not execution_context.result:
                         result = await await_maybe(
-                            execute_function(
+                            execute(
                                 self._schema,
                                 execution_context.graphql_document,
                                 root_value=execution_context.root_value,
@@ -546,9 +524,7 @@ class Schema(BaseSchema):
                         result = execution_context.result
                     # Also set errors on the execution_context so that it's easier
                     # to access in extensions
-
-                    # TODO: maybe here use the first result from incremental execution if it exists
-                    if isinstance(result, GraphQLExecutionResult) and result.errors:
+                    if result.errors:
                         execution_context.errors = result.errors
 
                         # Run the `Schema.process_errors` function here before
@@ -598,14 +574,6 @@ class Schema(BaseSchema):
         extensions_runner = self.create_extensions_runner(execution_context, extensions)
         middleware_manager = self._get_middleware_manager(extensions)
 
-        execute_function = (
-            experimental_execute_incrementally
-            if self.config.enable_experimental_incremental_execution
-            else execute
-        )
-
-        # TODO: raise if experimental_execute_incrementally is not available
-
         try:
             with extensions_runner.operation():
                 # Note: In graphql-core the schema would be validated here but in
@@ -647,7 +615,7 @@ class Schema(BaseSchema):
 
                 with extensions_runner.executing():
                     if not execution_context.result:
-                        result = execute_function(
+                        result = execute(
                             self._schema,
                             execution_context.graphql_document,
                             root_value=execution_context.root_value,
@@ -659,13 +627,13 @@ class Schema(BaseSchema):
                         )
 
                         if isawaitable(result):
-                            result = cast(Awaitable[GraphQLExecutionResult], result)  # type: ignore[redundant-cast]
+                            result = cast("Awaitable[GraphQLExecutionResult]", result)  # type: ignore[redundant-cast]
                             ensure_future(result).cancel()
                             raise RuntimeError(  # noqa: TRY301
                                 "GraphQL execution failed to complete synchronously."
                             )
 
-                        result = cast(GraphQLExecutionResult, result)  # type: ignore[redundant-cast]
+                        result = cast("GraphQLExecutionResult", result)  # type: ignore[redundant-cast]
                         execution_context.result = result
                         # Also set errors on the context so that it's easier
                         # to access in extensions
@@ -748,12 +716,13 @@ class Schema(BaseSchema):
                     )
                 else:
                     try:
-                        async for result in aiter_or_result:
-                            yield await self._handle_execution_result(
-                                execution_context,
-                                result,
-                                extensions_runner,
-                            )
+                        async with aclosing(aiter_or_result):
+                            async for result in aiter_or_result:
+                                yield await self._handle_execution_result(
+                                    execution_context,
+                                    result,
+                                    extensions_runner,
+                                )
                     # graphql-core doesn't handle exceptions raised while executing.
                     except Exception as exc:  # noqa: BLE001
                         yield await self._handle_execution_result(

strawberry/static/graphiql.html

@@ -1,4 +1,4 @@
-<!doctype html>
+<!DOCTYPE html>
 <html>
   <head>
     <title>Strawberry GraphiQL</title>
@@ -61,8 +61,8 @@
     <link
       crossorigin
       rel="stylesheet"
-      href="https://unpkg.com/graphiql@3.8.3/graphiql.min.css"
-      integrity="sha384-Mq3vbRBY71jfjQAt/DcjxUIYY33ksal4cgdRt9U/hNPvHBCaT2JfJ/PTRiPKf0aM"
+      href="https://unpkg.com/graphiql@3.0.9/graphiql.min.css"
+      integrity="sha384-yz3/sqpuplkA7msMo0FE4ekg0xdwdvZ8JX9MVZREsxipqjU4h8IRfmAMRcb1QpUy"
     />
 
     <link
@@ -77,8 +77,8 @@
     <div id="graphiql" class="graphiql-container">Loading...</div>
     <script
       crossorigin
-      src="https://unpkg.com/graphiql@3.8.3/graphiql.min.js"
-      integrity="sha384-HbRVEFG0JGJZeAHCJ9Xm2+tpknBQ7QZmNlO/DgZtkZ0aJSypT96YYGRNod99l9Ie"
+      src="https://unpkg.com/graphiql@3.0.9/graphiql.min.js"
+      integrity="sha384-Mjte+vxCWz1ZYCzszGHiJqJa5eAxiqI4mc3BErq7eDXnt+UGLXSEW7+i0wmfPiji"
     ></script>
     <script
       crossorigin

strawberry/subscriptions/protocols/graphql_transport_ws/handlers.py

@@ -77,7 +77,7 @@ class BaseGraphQLTransportWSHandler(Generic[Context, RootValue]):
         try:
             try:
                 async for message in self.websocket.iter_json():
-                    await self.handle_message(cast(Message, message))
+                    await self.handle_message(cast("Message", message))
             except NonTextMessageReceived:
                 await self.handle_invalid_message("WebSocket message type must be text")
             except NonJsonMessageReceived:

strawberry/subscriptions/protocols/graphql_ws/handlers.py

@@ -65,7 +65,7 @@ class BaseGraphQLWSHandler(Generic[Context, RootValue]):
                 async for message in self.websocket.iter_json(
                     ignore_parsing_errors=True
                 ):
-                    await self.handle_message(cast(OperationMessage, message))
+                    await self.handle_message(cast("OperationMessage", message))
             except NonTextMessageReceived:
                 await self.websocket.close(
                     code=1002, reason="WebSocket message type must be text"

strawberry/types/arguments.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import inspect
 import warnings
-from collections.abc import Iterable, Mapping
 from typing import (
     TYPE_CHECKING,
     Annotated,
@@ -27,6 +26,8 @@ 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 collections.abc import Iterable, Mapping
+
     from strawberry.schema.config import StrawberryConfig
     from strawberry.types.base import StrawberryType
     from strawberry.types.scalar import ScalarDefinition, ScalarWrapper
@@ -153,7 +154,7 @@ def convert_argument(
         return convert_argument(value, type_.of_type, scalar_registry, config)
 
     if isinstance(type_, StrawberryList):
-        value_list = cast(Iterable, value)
+        value_list = cast("Iterable", value)
         return [
             convert_argument(x, type_.of_type, scalar_registry, config)
             for x in value_list
@@ -177,7 +178,7 @@ def convert_argument(
 
         type_definition = type_.__strawberry_definition__
         for field in type_definition.fields:
-            value = cast(Mapping, value)
+            value = cast("Mapping", value)
             graphql_name = config.name_converter.from_field(field)
 
             if graphql_name in value:
@@ -188,7 +189,7 @@ def convert_argument(
                     config,
                 )
 
-        type_ = cast(type, type_)
+        type_ = cast("type", type_)
         return type_(**kwargs)
 
     raise UnsupportedTypeError(type_)

strawberry/types/auto.py

@@ -44,7 +44,7 @@ class StrawberryAutoMeta(type):
                 resolved = namespace and namespace.get(resolved)
 
             if resolved is not None:
-                instance = cast(type, resolved)
+                instance = cast("type", resolved)
 
         if instance is auto:
             return True

strawberry/types/field.py

@@ -369,7 +369,7 @@ class StrawberryField(dataclasses.Field):
             # If the field is still generic, try to resolve it from the type_definition
             # that is asking for it.
             if (
-                _is_generic(cast(Union[StrawberryType, type], resolved))
+                _is_generic(cast("Union[StrawberryType, type]", resolved))
                 and type_definition is not None
                 and type_definition.type_var_map
                 and isinstance(resolved, StrawberryType)

strawberry/types/fields/resolver.py

@@ -147,7 +147,7 @@ class ReservedType(NamedTuple):
         return None
 
     def is_reserved_type(self, other: builtins.type) -> bool:
-        origin = cast(type, get_origin(other)) or other
+        origin = cast("type", get_origin(other)) or other
         if origin is Annotated:
             # Handle annotated arguments such as Private[str] and DirectiveValue[str]
             return type_has_annotation(other, self.type)

strawberry/types/lazy_type.py

@@ -105,7 +105,7 @@ class StrawberryLazyReference:
             frame = sys._getframe(2)
             # TODO: raise a nice error if frame is None
             assert frame is not None
-            self.package = cast(str, frame.f_globals["__package__"])
+            self.package = cast("str", frame.f_globals["__package__"])
 
     def resolve_forward_ref(self, forward_ref: ForwardRef) -> LazyType:
         return LazyType(forward_ref.__forward_arg__, self.module, self.package)

strawberry/types/type_resolver.py

@@ -71,7 +71,7 @@ def _get_fields(
     # Find the class the each field was originally defined on so we can use
     # that scope later when resolving the type, as it may have different names
     # available to it.
-    origins: dict[str, type] = {field_name: cls for field_name in cls.__annotations__}
+    origins: dict[str, type] = dict.fromkeys(cls.__annotations__, cls)
 
     for base in cls.__mro__:
         if has_object_definition(base):