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

strawberry/ext/mypy_plugin.py

@@ -111,7 +111,9 @@ def lazy_type_analyze_callback(ctx: AnalyzeTypeContext) -> Type:
         return AnyType(TypeOfAny.special_form)
 
     type_name = ctx.type.args[0]
-    return ctx.api.analyze_type(type_name)
+    type_ = ctx.api.analyze_type(type_name)
+
+    return type_
 
 
 def _get_named_type(name: str, api: SemanticAnalyzerPluginInterface) -> Any:
@@ -145,12 +147,14 @@ def _get_type_for_expr(expr: Expression, api: SemanticAnalyzerPluginInterface) -
     if isinstance(expr, MemberExpr):
         if expr.fullname:
             return _get_named_type(expr.fullname, api)
-        raise InvalidNodeTypeException(expr)
+        else:
+            raise InvalidNodeTypeException(expr)
 
     if isinstance(expr, CallExpr):
         if expr.analyzed:
             return _get_type_for_expr(expr.analyzed, api)
-        raise InvalidNodeTypeException(expr)
+        else:
+            raise InvalidNodeTypeException(expr)
 
     if isinstance(expr, CastExpr):
         return expr.type
@@ -174,6 +178,8 @@ def create_type_hook(ctx: DynamicClassDefContext) -> None:
         SymbolTableNode(GDEF, type_alias, plugin_generated=True),
     )
 
+    return
+
 
 def union_hook(ctx: DynamicClassDefContext) -> None:
     try:
@@ -337,12 +343,13 @@ def add_static_method_to_class(
             cls.defs.body.remove(sym.node)
 
     # For compat with mypy < 0.93
-    if Decimal("0.93") > MypyVersion.VERSION:
+    if MypyVersion.VERSION < Decimal("0.93"):
         function_type = api.named_type("__builtins__.function")
-    elif isinstance(api, SemanticAnalyzerPluginInterface):
-        function_type = api.named_type("builtins.function")
     else:
-        function_type = api.named_generic_type("builtins.function", [])
+        if isinstance(api, SemanticAnalyzerPluginInterface):
+            function_type = api.named_type("builtins.function")
+        else:
+            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}"
             )
-        if is_legacy:
+        elif is_legacy:
             warnings.warn(self.DEPRECATION_MESSAGE, DeprecationWarning, stacklevel=3)
             return self.from_legacy(extension, on_start, on_end)
 
@@ -128,17 +128,19 @@ class ExtensionContextManagerBase:
 
             return WrappedHook(extension=extension, hook=iterator, is_async=True)
 
-        @contextlib.contextmanager
-        def iterator_async() -> Iterator[None]:
-            if on_start:
-                on_start()
+        else:
 
-            yield
+            @contextlib.contextmanager
+            def iterator_async() -> Iterator[None]:
+                if on_start:
+                    on_start()
+
+                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(
@@ -153,13 +155,14 @@ class ExtensionContextManagerBase:
                 yield
 
             return WrappedHook(extension=extension, hook=iterator, is_async=True)
+        else:
 
-        @contextlib.contextmanager  # type: ignore[no-redef]
-        def iterator() -> Iterator[None]:
-            func(extension)
-            yield
+            @contextlib.contextmanager
+            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()
@@ -172,7 +175,8 @@ class ExtensionContextManagerBase:
                     f"SchemaExtension hook {hook.extension}.{self.HOOK_NAME} "
                     "failed to complete synchronously."
                 )
-            self.exit_stack.enter_context(hook.hook())  # type: ignore
+            else:
+                self.exit_stack.enter_context(hook.hook())  # type: ignore
 
     def __exit__(
         self,

strawberry/extensions/field_extension.py

@@ -99,61 +99,62 @@ def build_field_extension_resolvers(
                 f"Please add a resolve_async method to the extension(s)."
             )
         return _get_async_resolvers(field.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
-    ]
-
-    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:]),
+    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:]),
+                )
             )
-        )
 
-    # 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."
-    )
+        # 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,17 +189,18 @@ def resolve_field_value(
 ) -> FieldArgumentType:
     if isinstance(value, StringValueNode):
         return value.value
-    if isinstance(value, IntValueNode):
+    elif isinstance(value, IntValueNode):
         return int(value.value)
-    if isinstance(value, FloatValueNode):
+    elif isinstance(value, FloatValueNode):
         return float(value.value)
-    if isinstance(value, BooleanValueNode):
+    elif isinstance(value, BooleanValueNode):
         return value.value
-    if isinstance(value, ListValueNode):
+    elif isinstance(value, ListValueNode):
         return [resolve_field_value(v) for v in value.values]
-    if isinstance(value, ObjectValueNode):
+    elif isinstance(value, ObjectValueNode):
         return {v.name.value: resolve_field_value(v.value) for v in value.fields}
-    return {}
+    else:
+        return {}
 
 
 def get_field_arguments(
@@ -249,18 +250,20 @@ def determine_depth(
             return 0
 
         return 1 + max(
-            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,
+            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,
             )
-            for selection in node.selection_set.selections
         )
-    if isinstance(node, FragmentSpreadNode):
+    elif isinstance(node, FragmentSpreadNode):
         return determine_depth(
             node=fragments[node.name.value],
             fragments=fragments,
@@ -270,22 +273,25 @@ def determine_depth(
             operation_name=operation_name,
             should_ignore=should_ignore,
         )
-    if isinstance(
+    elif isinstance(
         node, (InlineFragmentNode, FragmentDefinitionNode, OperationDefinitionNode)
     ):
         return max(
-            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,
+            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,
             )
-            for selection in node.selection_set.selections
         )
-    raise TypeError(f"Depth crawler cannot handle: {node.kind}")  # pragma: no cover
+    else:
+        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()  # noqa: S324
+        return hashlib.md5(query.encode("utf-8")).hexdigest()
 
     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 = {}
+        self._span_holder = dict()
         if execution_context:
             self.execution_context = execution_context
 
@@ -116,17 +116,18 @@ 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
-        if isinstance(value, (list, tuple, range)):
+        elif isinstance(value, (list, tuple, range)):
             return self.convert_list_or_tuple_to_allowed_types(value)
-        if isinstance(value, dict):
+        elif isinstance(value, dict):
             return self.convert_dict_to_allowed_types(value)
-        if isinstance(value, (set, frozenset)):
+        elif isinstance(value, (set, frozenset)):
             return self.convert_set_to_allowed_types(value)
-        if isinstance(value, complex):
+        elif isinstance(value, complex):
             return str(value)  # Convert complex numbers to strings
-        if isinstance(value, (bytearray, memoryview)):
+        elif isinstance(value, (bytearray, memoryview)):
             return bytes(value)  # Convert bytearray and memoryview to bytes
-        return str(value)
+        else:
+            return str(value)
 
     def convert_set_to_allowed_types(self, value: Union[set, frozenset]) -> str:
         return (
@@ -191,7 +192,9 @@ class OpenTelemetryExtensionSync(OpenTelemetryExtension):
         **kwargs: Any,
     ) -> Any:
         if should_skip_tracing(_next, info):
-            return _next(root, info, *args, **kwargs)
+            result = _next(root, info, *args, **kwargs)
+
+            return result
 
         with self._tracer.start_as_current_span(
             f"GraphQL Resolving: {info.field_name}",
@@ -200,7 +203,9 @@ class OpenTelemetryExtensionSync(OpenTelemetryExtension):
             ),
         ) as span:
             self.add_tags(span, info, kwargs)
-            return _next(root, info, *args, **kwargs)
+            result = _next(root, info, *args, **kwargs)
+
+            return result
 
 
 __all__ = ["OpenTelemetryExtension", "OpenTelemetryExtensionSync"]

strawberry/fastapi/router.py

@@ -92,9 +92,10 @@ class GraphQLRouter(
                     **default_context,
                     **custom_context,
                 }
-            if custom_context is None:
+            elif custom_context is None:
                 return default_context
-            raise InvalidCustomContext
+            else:
+                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:  # noqa: BLE001
+                except Exception as e:
                     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:  # noqa: BLE001
+                except Exception:
                     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_=sorted(directives),  # type: ignore[arg-type]
+                import_=list(sorted(directives)),
             )
             for url, directives in directive_by_url.items()
         ]

strawberry/flask/views.py

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

strawberry/http/async_base_view.py

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

strawberry/http/ides.py

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

strawberry/http/sync_base_view.py

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

strawberry/litestar/controller.py

@@ -9,7 +9,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    ClassVar,
     Optional,
     TypedDict,
     Union,
@@ -204,13 +203,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 as e:
+                except json.JSONDecodeError:
                     if not ignore_parsing_errors:
-                        raise NonJsonMessageReceived from e
+                        raise NonJsonMessageReceived()
         except WebSocketDisconnect:
             pass
 
@@ -237,7 +236,7 @@ class GraphQLController(
     ],
 ):
     path: str = ""
-    dependencies: ClassVar[Dependencies] = {  # type: ignore[misc]
+    dependencies: Dependencies = {
         "custom_context": Provide(_none_custom_context_getter),
         "context": Provide(_context_getter_http),
         "context_ws": Provide(_context_getter_ws),
@@ -446,7 +445,7 @@ def make_graphql_controller(
 
     class _GraphQLController(GraphQLController):
         path: str = routes_path
-        dependencies: ClassVar[Dependencies] = {  # type: ignore[misc]
+        dependencies: Dependencies = {
             "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 = {}
+                error.extensions = dict()
             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, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, Callable, Optional, cast
 from typing_extensions import TypeGuard
 
 from quart import Request, Response, request
@@ -52,7 +52,7 @@ class GraphQLView(
     ],
     View,
 ):
-    methods: ClassVar[list[str]] = ["GET", "POST"]
+    methods = ["GET", "POST"]
     allow_queries_via_get: bool = True
     request_adapter_class = QuartHTTPRequestAdapter
 

strawberry/relay/fields.py

@@ -37,7 +37,6 @@ 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
@@ -89,27 +88,12 @@ class NodeExtension(FieldExtension):
             info: Info,
             id: Annotated[GlobalID, argument(description="The ID of the object.")],
         ) -> Union[Node, None, Awaitable[Union[Node, None]]]:
-            node_type = id.resolve_type(info)
-            resolved_node = node_type.resolve_node(
+            return id.resolve_type(info).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(
@@ -155,14 +139,6 @@ 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]:
@@ -185,8 +161,7 @@ class NodeExtension(FieldExtension):
 
                     # Resolve any generator to lists
                     resolved = {
-                        node_t: cast_nodes(node_t, nodes)
-                        for node_t, nodes in resolved.items()
+                        node_t: list(nodes) for node_t, nodes in resolved.items()
                     }
                     return [
                         resolved[index_map[gid][0]][index_map[gid][1]] for gid in ids
@@ -196,7 +171,7 @@ class NodeExtension(FieldExtension):
 
             # Resolve any generator to lists
             resolved = {
-                node_t: cast_nodes(node_t, cast(Iterable[Node], nodes))
+                node_t: list(cast(Iterator[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(  # noqa: PLR0915
+    def resolve_connection(
         cls,
         nodes: NodeIterableType[NodeType],
         *,