strawberry-graphql 0.256.1__py3-none-any.whl → 0.257.0__py3-none-any.whl

strawberry/ext/mypy_plugin.py

@@ -111,9 +111,7 @@ def lazy_type_analyze_callback(ctx: AnalyzeTypeContext) -> Type:
         return AnyType(TypeOfAny.special_form)
 
     type_name = ctx.type.args[0]
-    type_ = ctx.api.analyze_type(type_name)
-
-    return type_
+    return ctx.api.analyze_type(type_name)
 
 
 def _get_named_type(name: str, api: SemanticAnalyzerPluginInterface) -> Any:
@@ -147,14 +145,12 @@ def _get_type_for_expr(expr: Expression, api: SemanticAnalyzerPluginInterface) -
     if isinstance(expr, MemberExpr):
         if expr.fullname:
             return _get_named_type(expr.fullname, api)
-        else:
-            raise InvalidNodeTypeException(expr)
+        raise InvalidNodeTypeException(expr)
 
     if isinstance(expr, CallExpr):
         if expr.analyzed:
             return _get_type_for_expr(expr.analyzed, api)
-        else:
-            raise InvalidNodeTypeException(expr)
+        raise InvalidNodeTypeException(expr)
 
     if isinstance(expr, CastExpr):
         return expr.type
@@ -178,8 +174,6 @@ def create_type_hook(ctx: DynamicClassDefContext) -> None:
         SymbolTableNode(GDEF, type_alias, plugin_generated=True),
     )
 
-    return
-
 
 def union_hook(ctx: DynamicClassDefContext) -> None:
     try:
@@ -343,13 +337,12 @@ def add_static_method_to_class(
             cls.defs.body.remove(sym.node)
 
     # For compat with mypy < 0.93
-    if MypyVersion.VERSION < Decimal("0.93"):
+    if Decimal("0.93") > MypyVersion.VERSION:
         function_type = api.named_type("__builtins__.function")
+    elif isinstance(api, SemanticAnalyzerPluginInterface):
+        function_type = api.named_type("builtins.function")
     else:
-        if isinstance(api, SemanticAnalyzerPluginInterface):
-            function_type = api.named_type("builtins.function")
-        else:
-            function_type = api.named_generic_type("builtins.function", [])
+        function_type = api.named_generic_type("builtins.function", [])
 
     arg_types, arg_names, arg_kinds = [], [], []
     for arg in args:

strawberry/extensions/context.py

@@ -77,7 +77,7 @@ class ExtensionContextManagerBase:
                 f"{extension} defines both legacy and new style extension hooks for "
                 "{self.HOOK_NAME}"
             )
-        elif is_legacy:
+        if is_legacy:
             warnings.warn(self.DEPRECATION_MESSAGE, DeprecationWarning, stacklevel=3)
             return self.from_legacy(extension, on_start, on_end)
 
@@ -128,19 +128,17 @@ class ExtensionContextManagerBase:
 
             return WrappedHook(extension=extension, hook=iterator, is_async=True)
 
-        else:
+        @contextlib.contextmanager
+        def iterator_async() -> Iterator[None]:
+            if on_start:
+                on_start()
 
-            @contextlib.contextmanager
-            def iterator_async() -> Iterator[None]:
-                if on_start:
-                    on_start()
-
-                yield
+            yield
 
-                if on_end:
-                    on_end()
+            if on_end:
+                on_end()
 
-            return WrappedHook(extension=extension, hook=iterator_async, is_async=False)
+        return WrappedHook(extension=extension, hook=iterator_async, is_async=False)
 
     @staticmethod
     def from_callable(
@@ -155,14 +153,13 @@ class ExtensionContextManagerBase:
                 yield
 
             return WrappedHook(extension=extension, hook=iterator, is_async=True)
-        else:
 
-            @contextlib.contextmanager
-            def iterator() -> Iterator[None]:
-                func(extension)
-                yield
+        @contextlib.contextmanager  # type: ignore[no-redef]
+        def iterator() -> Iterator[None]:
+            func(extension)
+            yield
 
-            return WrappedHook(extension=extension, hook=iterator, is_async=False)
+        return WrappedHook(extension=extension, hook=iterator, is_async=False)
 
     def __enter__(self) -> None:
         self.exit_stack = contextlib.ExitStack()
@@ -175,8 +172,7 @@ class ExtensionContextManagerBase:
                     f"SchemaExtension hook {hook.extension}.{self.HOOK_NAME} "
                     "failed to complete synchronously."
                 )
-            else:
-                self.exit_stack.enter_context(hook.hook())  # type: ignore
+            self.exit_stack.enter_context(hook.hook())  # type: ignore
 
     def __exit__(
         self,

strawberry/extensions/field_extension.py

@@ -99,62 +99,61 @@ def build_field_extension_resolvers(
                 f"Please add a resolve_async method to the extension(s)."
             )
         return _get_async_resolvers(field.extensions)
-    else:
-        # Try to wrap all sync resolvers in async so that we can use async extensions
-        # on sync fields. This is not possible the other way around since
-        # the result of an async resolver would have to be awaited before calling
-        # the sync extension, making it impossible for the extension to modify
-        # any arguments.
-        non_sync_extensions = [
-            extension for extension in field.extensions if not extension.supports_sync
-        ]
-
-        if len(non_sync_extensions) == 0:
-            # Resolve everything sync
-            return _get_sync_resolvers(field.extensions)
-
-        # We have async-only extensions and need to wrap the resolver
-        # That means we can't have sync-only extensions after the first async one
-
-        # Check if we have a chain of sync-compatible
-        # extensions before the async extensions
-        # -> S-S-S-S-A-A-A-A
-        found_sync_extensions = 0
-
-        # All sync only extensions must be found before the first async-only one
-        found_sync_only_extensions = 0
-        for extension in field.extensions:
-            # ...A, abort
-            if extension in non_sync_extensions:
-                break
-            # ...S
-            if extension in non_async_extensions:
-                found_sync_only_extensions += 1
-            found_sync_extensions += 1
-
-        # Length of the chain equals length of non async extensions
-        # All sync extensions run first
-        if len(non_async_extensions) == found_sync_only_extensions:
-            # Prepend sync to async extension to field extensions
-            return list(
-                itertools.chain(
-                    _get_sync_resolvers(field.extensions[:found_sync_extensions]),
-                    [SyncToAsyncExtension().resolve_async],
-                    _get_async_resolvers(field.extensions[found_sync_extensions:]),
-                )
-            )
+    # Try to wrap all sync resolvers in async so that we can use async extensions
+    # on sync fields. This is not possible the other way around since
+    # the result of an async resolver would have to be awaited before calling
+    # the sync extension, making it impossible for the extension to modify
+    # any arguments.
+    non_sync_extensions = [
+        extension for extension in field.extensions if not extension.supports_sync
+    ]
 
-        # Some sync extensions follow the first async-only extension. Error case
-        async_extension_names = ",".join(
-            [extension.__class__.__name__ for extension in non_sync_extensions]
-        )
-        raise TypeError(
-            f"Cannot mix async-only extension(s) {async_extension_names} "
-            f"with sync-only extension(s) {non_async_extension_names} "
-            f"on Field {field.name}. "
-            f"If possible try to change the execution order so that all sync-only "
-            f"extensions are executed first."
+    if len(non_sync_extensions) == 0:
+        # Resolve everything sync
+        return _get_sync_resolvers(field.extensions)
+
+    # We have async-only extensions and need to wrap the resolver
+    # That means we can't have sync-only extensions after the first async one
+
+    # Check if we have a chain of sync-compatible
+    # extensions before the async extensions
+    # -> S-S-S-S-A-A-A-A
+    found_sync_extensions = 0
+
+    # All sync only extensions must be found before the first async-only one
+    found_sync_only_extensions = 0
+    for extension in field.extensions:
+        # ...A, abort
+        if extension in non_sync_extensions:
+            break
+        # ...S
+        if extension in non_async_extensions:
+            found_sync_only_extensions += 1
+        found_sync_extensions += 1
+
+    # Length of the chain equals length of non async extensions
+    # All sync extensions run first
+    if len(non_async_extensions) == found_sync_only_extensions:
+        # Prepend sync to async extension to field extensions
+        return list(
+            itertools.chain(
+                _get_sync_resolvers(field.extensions[:found_sync_extensions]),
+                [SyncToAsyncExtension().resolve_async],
+                _get_async_resolvers(field.extensions[found_sync_extensions:]),
+            )
         )
 
+    # Some sync extensions follow the first async-only extension. Error case
+    async_extension_names = ",".join(
+        [extension.__class__.__name__ for extension in non_sync_extensions]
+    )
+    raise TypeError(
+        f"Cannot mix async-only extension(s) {async_extension_names} "
+        f"with sync-only extension(s) {non_async_extension_names} "
+        f"on Field {field.name}. "
+        f"If possible try to change the execution order so that all sync-only "
+        f"extensions are executed first."
+    )
+
 
 __all__ = ["FieldExtension"]

strawberry/extensions/query_depth_limiter.py

@@ -189,18 +189,17 @@ def resolve_field_value(
 ) -> FieldArgumentType:
     if isinstance(value, StringValueNode):
         return value.value
-    elif isinstance(value, IntValueNode):
+    if isinstance(value, IntValueNode):
         return int(value.value)
-    elif isinstance(value, FloatValueNode):
+    if isinstance(value, FloatValueNode):
         return float(value.value)
-    elif isinstance(value, BooleanValueNode):
+    if isinstance(value, BooleanValueNode):
         return value.value
-    elif isinstance(value, ListValueNode):
+    if isinstance(value, ListValueNode):
         return [resolve_field_value(v) for v in value.values]
-    elif isinstance(value, ObjectValueNode):
+    if isinstance(value, ObjectValueNode):
         return {v.name.value: resolve_field_value(v.value) for v in value.fields}
-    else:
-        return {}
+    return {}
 
 
 def get_field_arguments(
@@ -250,20 +249,18 @@ def determine_depth(
             return 0
 
         return 1 + max(
-            map(
-                lambda selection: determine_depth(
-                    node=selection,
-                    fragments=fragments,
-                    depth_so_far=depth_so_far + 1,
-                    max_depth=max_depth,
-                    context=context,
-                    operation_name=operation_name,
-                    should_ignore=should_ignore,
-                ),
-                node.selection_set.selections,
+            determine_depth(
+                node=selection,
+                fragments=fragments,
+                depth_so_far=depth_so_far + 1,
+                max_depth=max_depth,
+                context=context,
+                operation_name=operation_name,
+                should_ignore=should_ignore,
             )
+            for selection in node.selection_set.selections
         )
-    elif isinstance(node, FragmentSpreadNode):
+    if isinstance(node, FragmentSpreadNode):
         return determine_depth(
             node=fragments[node.name.value],
             fragments=fragments,
@@ -273,25 +270,22 @@ def determine_depth(
             operation_name=operation_name,
             should_ignore=should_ignore,
         )
-    elif isinstance(
+    if isinstance(
         node, (InlineFragmentNode, FragmentDefinitionNode, OperationDefinitionNode)
     ):
         return max(
-            map(
-                lambda selection: determine_depth(
-                    node=selection,
-                    fragments=fragments,
-                    depth_so_far=depth_so_far,
-                    max_depth=max_depth,
-                    context=context,
-                    operation_name=operation_name,
-                    should_ignore=should_ignore,
-                ),
-                node.selection_set.selections,
+            determine_depth(
+                node=selection,
+                fragments=fragments,
+                depth_so_far=depth_so_far,
+                max_depth=max_depth,
+                context=context,
+                operation_name=operation_name,
+                should_ignore=should_ignore,
             )
+            for selection in node.selection_set.selections
         )
-    else:
-        raise TypeError(f"Depth crawler cannot handle: {node.kind}")  # pragma: no cover
+    raise TypeError(f"Depth crawler cannot handle: {node.kind}")  # pragma: no cover
 
 
 def is_ignored(node: FieldNode, ignore: Optional[list[IgnoreType]] = None) -> bool:

strawberry/extensions/tracing/datadog.py

@@ -67,7 +67,7 @@ class DatadogTracingExtension(SchemaExtension):
         )
 
     def hash_query(self, query: str) -> str:
-        return hashlib.md5(query.encode("utf-8")).hexdigest()
+        return hashlib.md5(query.encode("utf-8")).hexdigest()  # noqa: S324
 
     def on_operation(self) -> Iterator[None]:
         self._operation_name = self.execution_context.operation_name

strawberry/extensions/tracing/opentelemetry.py

@@ -45,7 +45,7 @@ class OpenTelemetryExtension(SchemaExtension):
     ) -> None:
         self._arg_filter = arg_filter
         self._tracer = trace.get_tracer("strawberry")
-        self._span_holder = dict()
+        self._span_holder = {}
         if execution_context:
             self.execution_context = execution_context
 
@@ -116,18 +116,17 @@ class OpenTelemetryExtension(SchemaExtension):
         # Put these in decreasing order of use-cases to exit as soon as possible
         if isinstance(value, (bool, str, bytes, int, float)):
             return value
-        elif isinstance(value, (list, tuple, range)):
+        if isinstance(value, (list, tuple, range)):
             return self.convert_list_or_tuple_to_allowed_types(value)
-        elif isinstance(value, dict):
+        if isinstance(value, dict):
             return self.convert_dict_to_allowed_types(value)
-        elif isinstance(value, (set, frozenset)):
+        if isinstance(value, (set, frozenset)):
             return self.convert_set_to_allowed_types(value)
-        elif isinstance(value, complex):
+        if isinstance(value, complex):
             return str(value)  # Convert complex numbers to strings
-        elif isinstance(value, (bytearray, memoryview)):
+        if isinstance(value, (bytearray, memoryview)):
             return bytes(value)  # Convert bytearray and memoryview to bytes
-        else:
-            return str(value)
+        return str(value)
 
     def convert_set_to_allowed_types(self, value: Union[set, frozenset]) -> str:
         return (
@@ -192,9 +191,7 @@ class OpenTelemetryExtensionSync(OpenTelemetryExtension):
         **kwargs: Any,
     ) -> Any:
         if should_skip_tracing(_next, info):
-            result = _next(root, info, *args, **kwargs)
-
-            return result
+            return _next(root, info, *args, **kwargs)
 
         with self._tracer.start_as_current_span(
             f"GraphQL Resolving: {info.field_name}",
@@ -203,9 +200,7 @@ class OpenTelemetryExtensionSync(OpenTelemetryExtension):
             ),
         ) as span:
             self.add_tags(span, info, kwargs)
-            result = _next(root, info, *args, **kwargs)
-
-            return result
+            return _next(root, info, *args, **kwargs)
 
 
 __all__ = ["OpenTelemetryExtension", "OpenTelemetryExtensionSync"]

strawberry/fastapi/router.py

@@ -92,10 +92,9 @@ class GraphQLRouter(
                     **default_context,
                     **custom_context,
                 }
-            elif custom_context is None:
+            if custom_context is None:
                 return default_context
-            else:
-                raise InvalidCustomContext()
+            raise InvalidCustomContext
 
         # replace the signature parameters of dependency...
         # ...with the old parameters minus the first argument as it will be replaced...

strawberry/federation/schema.py

@@ -172,7 +172,7 @@ class Schema(BaseSchema):
 
                 try:
                     result = resolve_reference(**kwargs)
-                except Exception as e:
+                except Exception as e:  # noqa: BLE001
                     result = e
             else:
                 from strawberry.types.arguments import convert_argument
@@ -187,7 +187,7 @@ class Schema(BaseSchema):
                         scalar_registry=scalar_registry,
                         config=config,
                     )
-                except Exception:
+                except Exception:  # noqa: BLE001
                     result = TypeError(f"Unable to resolve reference for {type_name}")
 
             results.append(result)
@@ -271,7 +271,7 @@ class Schema(BaseSchema):
         link_directives: list[object] = [
             Link(
                 url=url,
-                import_=list(sorted(directives)),
+                import_=sorted(directives),  # type: ignore[arg-type]
             )
             for url, directives in directive_by_url.items()
         ]

strawberry/flask/views.py

@@ -4,6 +4,7 @@ import warnings
 from typing import (
     TYPE_CHECKING,
     Any,
+    ClassVar,
     Optional,
     Union,
     cast,
@@ -102,7 +103,7 @@ class GraphQLView(
     SyncBaseHTTPView[Request, Response, Response, Context, RootValue],
     View,
 ):
-    methods = ["GET", "POST"]
+    methods: ClassVar[list[str]] = ["GET", "POST"]
     allow_queries_via_get: bool = True
     request_adapter_class = FlaskHTTPRequestAdapter
 
@@ -165,7 +166,7 @@ class AsyncGraphQLView(
     ],
     View,
 ):
-    methods = ["GET", "POST"]
+    methods: ClassVar[list[str]] = ["GET", "POST"]
     allow_queries_via_get: bool = True
     request_adapter_class = AsyncFlaskHTTPRequestAdapter
 

strawberry/http/async_base_view.py

@@ -306,8 +306,7 @@ class AsyncBaseHTTPView(
                 await websocket.close(4406, "Subprotocol not acceptable")
 
             return websocket_response
-        else:
-            request = cast(Request, request)
+        request = cast(Request, request)
 
         request_adapter = self.request_adapter_class(request)
         sub_response = await self.get_sub_response(request)
@@ -325,8 +324,7 @@ class AsyncBaseHTTPView(
         if self.should_render_graphql_ide(request_adapter):
             if self.graphql_ide:
                 return await self.render_graphql_ide(request)
-            else:
-                raise HTTPException(404, "Not Found")
+            raise HTTPException(404, "Not Found")
 
         try:
             result = await self.execute_operation(

strawberry/http/ides.py

@@ -17,9 +17,7 @@ def get_graphql_ide_html(
     else:
         path = here / "static/graphiql.html"
 
-    template = path.read_text(encoding="utf-8")
-
-    return template
+    return path.read_text(encoding="utf-8")
 
 
 __all__ = ["GraphQL_IDE", "get_graphql_ide_html"]

strawberry/http/sync_base_view.py

@@ -175,8 +175,7 @@ class SyncBaseHTTPView(
         if self.should_render_graphql_ide(request_adapter):
             if self.graphql_ide:
                 return self.render_graphql_ide(request)
-            else:
-                raise HTTPException(404, "Not Found")
+            raise HTTPException(404, "Not Found")
 
         sub_response = self.get_sub_response(request)
         context = (

strawberry/litestar/controller.py

@@ -9,6 +9,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
+    ClassVar,
     Optional,
     TypedDict,
     Union,
@@ -203,13 +204,13 @@ class LitestarWebSocketAdapter(AsyncWebSocketAdapter):
 
                 # Litestar internally defaults to an empty string for non-text messages
                 if text == "":
-                    raise NonTextMessageReceived()
+                    raise NonTextMessageReceived
 
                 try:
                     yield self.view.decode_json(text)
-                except json.JSONDecodeError:
+                except json.JSONDecodeError as e:
                     if not ignore_parsing_errors:
-                        raise NonJsonMessageReceived()
+                        raise NonJsonMessageReceived from e
         except WebSocketDisconnect:
             pass
 
@@ -236,7 +237,7 @@ class GraphQLController(
     ],
 ):
     path: str = ""
-    dependencies: Dependencies = {
+    dependencies: ClassVar[Dependencies] = {  # type: ignore[misc]
         "custom_context": Provide(_none_custom_context_getter),
         "context": Provide(_context_getter_http),
         "context_ws": Provide(_context_getter_ws),
@@ -445,7 +446,7 @@ def make_graphql_controller(
 
     class _GraphQLController(GraphQLController):
         path: str = routes_path
-        dependencies: Dependencies = {
+        dependencies: ClassVar[Dependencies] = {  # type: ignore[misc]
             "custom_context": Provide(custom_context_getter_),
             "context": Provide(_context_getter_http),
             "context_ws": Provide(_context_getter_ws),

strawberry/permission.py

@@ -101,7 +101,7 @@ class BasePermission(abc.ABC):
         if self.error_extensions:
             # Add our extensions to the error
             if not error.extensions:
-                error.extensions = dict()
+                error.extensions = {}
             error.extensions.update(self.error_extensions)
 
         raise error

strawberry/quart/views.py

@@ -1,6 +1,6 @@
 import warnings
 from collections.abc import AsyncGenerator, Mapping
-from typing import TYPE_CHECKING, Callable, Optional, cast
+from typing import TYPE_CHECKING, Callable, ClassVar, Optional, cast
 from typing_extensions import TypeGuard
 
 from quart import Request, Response, request
@@ -52,7 +52,7 @@ class GraphQLView(
     ],
     View,
 ):
-    methods = ["GET", "POST"]
+    methods: ClassVar[list[str]] = ["GET", "POST"]
     allow_queries_via_get: bool = True
     request_adapter_class = QuartHTTPRequestAdapter
 

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]

strawberry/relay/types.py

@@ -758,7 +758,7 @@ class ListConnection(Connection[NodeType]):
     )
 
     @classmethod
-    def resolve_connection(
+    def resolve_connection(  # noqa: PLR0915
         cls,
         nodes: NodeIterableType[NodeType],
         *,