Some simplifications with walrus operator

Author: Cito

src/graphql/execution/middleware.py

@@ -61,7 +61,6 @@ def get_middleware_resolvers(middlewares: tuple[Any, ...]) -> Iterator[Callable]
     for middleware in middlewares:
         if isfunction(middleware):
             yield middleware
-        else:  # middleware provided as object with 'resolve' method
-            resolver_func = getattr(middleware, "resolve", None)
-            if resolver_func is not None:
-                yield resolver_func
+        elif resolver_func := getattr(middleware, "resolve", None):
+            # middleware provided as object with 'resolve' method
+            yield resolver_func

src/graphql/graphql.py

@@ -176,8 +176,7 @@ def graphql_impl(
 ) -> AwaitableOrValue[ExecutionResult]:
     """Execute a query, return asynchronously only if necessary."""
     # Validate Schema
-    schema_validation_errors = validate_schema(schema)
-    if schema_validation_errors:
+    if schema_validation_errors := validate_schema(schema):
         return ExecutionResult(data=None, errors=schema_validation_errors)
 
     # Parse
@@ -189,8 +188,7 @@ def graphql_impl(
     # Validate
     from .validation import validate
 
-    validation_errors = validate(schema, document)
-    if validation_errors:
+    if validation_errors := validate(schema, document):
         return ExecutionResult(data=None, errors=validation_errors)
 
     # Execute

src/graphql/validation/rules/fragments_on_composite_types.py

@@ -25,24 +25,26 @@ class FragmentsOnCompositeTypesRule(ValidationRule):
 
     def enter_inline_fragment(self, node: InlineFragmentNode, *_args: Any) -> None:
         type_condition = node.type_condition
-        if type_condition:
-            type_ = type_from_ast(self.context.schema, type_condition)
-            if type_ and not is_composite_type(type_):
-                type_str = print_ast(type_condition)
-                self.report_error(
-                    GraphQLError(
-                        "Fragment cannot condition"
-                        f" on non composite type '{type_str}'.",
-                        type_condition,
-                    )
+        if (
+            type_condition
+            and (type_ := type_from_ast(self.context.schema, type_condition))
+            and not is_composite_type(type_)
+        ):
+            type_str = print_ast(type_condition)
+            self.report_error(
+                GraphQLError(
+                    f"Fragment cannot condition on non composite type '{type_str}'.",
+                    type_condition,
                 )
+            )
 
     def enter_fragment_definition(
         self, node: FragmentDefinitionNode, *_args: Any
     ) -> None:
         type_condition = node.type_condition
-        type_ = type_from_ast(self.context.schema, type_condition)
-        if type_ and not is_composite_type(type_):
+        if (
+            type_ := type_from_ast(self.context.schema, type_condition)
+        ) and not is_composite_type(type_):
             type_str = print_ast(type_condition)
             self.report_error(
                 GraphQLError(

src/graphql/validation/validation_context.py

@@ -166,8 +166,7 @@ def get_recursively_referenced_fragments(
                     frag_name = spread.name.value
                     if frag_name not in collected_names:
                         add_name(frag_name)
-                        fragment = get_fragment(frag_name)
-                        if fragment:
+                        if fragment := get_fragment(frag_name):
                             append_fragment(fragment)
                             append_node(fragment.selection_set)
             self._recursively_referenced_fragments[operation] = fragments