openrewrite-migrate-python 0.16.0.dev20261006155312__tar.gz → 0.16.0.dev20261007033737__tar.gz

{openrewrite_migrate_python-0.16.0.dev20261006155312 → openrewrite_migrate_python-0.16.0.dev20261007033737}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.16.0.dev20261006155312
+Version: 0.16.0.dev20261007033737
 Summary: OpenRewrite recipes for migrating Python codebases to newer Python versions.
 Author-email: "Moderne Inc." <support@moderne.io>
 License: Moderne Proprietary

{openrewrite_migrate_python-0.16.0.dev20261006155312 → openrewrite_migrate_python-0.16.0.dev20261007033737}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "openrewrite-migrate-python"
 description = "OpenRewrite recipes for migrating Python codebases to newer Python versions."
-version = "0.16.0.dev20261006155312"  # Updated dynamically during release
+version = "0.16.0.dev20261007033737"  # Updated dynamically during release
 authors = [{ name = "Moderne Inc.", email = "support@moderne.io" }]
 license = { text = "Moderne Proprietary" }
 readme = "README.md"

openrewrite_migrate_python-0.16.0.dev20261007033737/src/openrewrite_code_quality_python/codequality/_side_effects.py

@@ -0,0 +1,36 @@
+from rewrite.java.tree import (
+    Binary as JBinary,
+    Expression,
+    FieldAccess,
+    Identifier,
+    Literal,
+    Parentheses,
+    Ternary,
+    Unary,
+)
+from rewrite.python.tree import Binary as PyBinary
+
+
+def is_side_effect_free(expr: Expression) -> bool:
+    """Whether evaluating ``expr`` is taken to have no side effects.
+
+    Names, literals, attribute reads and operators over them are taken as pure.
+    A call, subscript, walrus, ``await`` or any other node may run code that matters.
+    """
+    if isinstance(expr, (Identifier, Literal)):
+        return True
+    if isinstance(expr, FieldAccess):
+        return is_side_effect_free(expr.target)
+    if isinstance(expr, Parentheses):
+        return isinstance(expr.tree, Expression) and is_side_effect_free(expr.tree)
+    if isinstance(expr, Unary):
+        return is_side_effect_free(expr.expression)
+    if isinstance(expr, (JBinary, PyBinary)):
+        return is_side_effect_free(expr.left) and is_side_effect_free(expr.right)
+    if isinstance(expr, Ternary):
+        return (
+            is_side_effect_free(expr.condition)
+            and is_side_effect_free(expr.true_part)
+            and is_side_effect_free(expr.false_part)
+        )
+    return False

{openrewrite_migrate_python-0.16.0.dev20261006155312 → openrewrite_migrate_python-0.16.0.dev20261007033737}/src/openrewrite_code_quality_python/codequality/all_branches_identical.py

@@ -27,6 +27,7 @@ from openrewrite_code_quality_python.codequality._reindent import (
     reindent,
 )
 from openrewrite_code_quality_python.codequality._semantically_equal import SemanticallyEqual
+from openrewrite_code_quality_python.codequality._side_effects import is_side_effect_free
 
 _CodeQuality = [
     *Python,
@@ -68,6 +69,17 @@ def _collect_bodies(if_: If) -> list[Statement]:
     return bodies
 
 
+def _conditions_side_effect_free(if_: If) -> bool:
+    current = if_
+    while True:
+        if not is_side_effect_free(current.if_condition.tree):
+            return False
+        else_part = current.else_part
+        if else_part is None or not isinstance(else_part.body, If):
+            return True
+        current = else_part.body
+
+
 def _all_bodies_equal(bodies: list[Statement]) -> bool:
     """Return True when every body is semantically equal to the first."""
     if len(bodies) < 2:
@@ -90,7 +102,8 @@ class AllBranchesIdentical(Recipe):
     and eliminates a source of confusion for future readers.
 
     Only applies when the chain has an explicit ``else`` so that the
-    branches truly cover all cases.
+    branches truly cover all cases, and when no condition may have a
+    side effect that removing it would lose.
 
     Example:
         Before:
@@ -116,7 +129,8 @@ class AllBranchesIdentical(Recipe):
         return (
             "Replace `if`/`elif`/`else` chains where every branch has "
             "the same body with just the body, since the condition has "
-            "no effect on what code executes."
+            "no effect on what code executes. A chain whose conditions may "
+            "have side effects, such as a call, is left alone."
         )
 
     @property
@@ -163,7 +177,7 @@ def _replace_identical_ifs_padded(padded_stmts) -> Optional[list]:
         if not isinstance(s, If):
             result.append(rp)
             continue
-        if not _has_explicit_else(s):
+        if not _has_explicit_else(s) or not _conditions_side_effect_free(s):
             result.append(rp)
             continue
         bodies = _collect_bodies(s)

{openrewrite_migrate_python-0.16.0.dev20261006155312 → openrewrite_migrate_python-0.16.0.dev20261007033737}/src/openrewrite_code_quality_python/codequality/boolean_checks_not_inverted.py

@@ -10,16 +10,20 @@ See: https://rules.sonarsource.com/python/RSPEC-S1940/
 
 from typing import Any, List, Optional
 
-from rewrite import ExecutionContext, Recipe, TreeVisitor
+from rewrite import Cursor, ExecutionContext, Recipe, TreeVisitor
 from rewrite.category import CategoryDescriptor
 from rewrite.decorators import categorize
 from rewrite.marketplace import Python
+from rewrite.python.tree import Binary as PyBinary
 from rewrite.python.visitor import PythonVisitor
-from rewrite.java.support_types import JLeftPadded, Space
+from rewrite.java.support_types import JavaType, JLeftPadded
 from rewrite.java.tree import (
+    Assert,
     Binary as JBinary,
+    ControlParentheses,
     Expression,
     Parentheses,
+    Ternary,
     Unary,
 )
 
@@ -37,6 +41,59 @@ _OPERATOR_INVERSE = {
     JBinary.Type.GreaterThanOrEqual: JBinary.Type.LessThan,
 }
 
+_EQUALITY = {JBinary.Type.Equal, JBinary.Type.NotEqual}
+
+_COMPARISONS = {
+    *_OPERATOR_INVERSE,
+    PyBinary.Type.In,
+    PyBinary.Type.NotIn,
+    PyBinary.Type.Is,
+    PyBinary.Type.IsNot,
+}
+
+_NUMERIC = {
+    JavaType.Primitive.Boolean,
+    JavaType.Primitive.Int,
+    JavaType.Primitive.Long,
+    JavaType.Primitive.Double,
+    JavaType.Primitive.Float,
+}
+
+
+def _is_comparison(expr: Expression) -> bool:
+    return isinstance(expr, (JBinary, PyBinary)) and expr.operator in _COMPARISONS
+
+
+def _is_invertible(comparison: JBinary) -> bool:
+    # `a < b < c` is one chained comparison whose last link is the outer node.
+    if _is_comparison(comparison.left) or _is_comparison(comparison.right):
+        return False
+    # Only numbers are totally ordered. A set orders by inclusion.
+    return comparison.operator in _EQUALITY or (
+        comparison.left.type in _NUMERIC and comparison.right.type in _NUMERIC
+    )
+
+
+def _is_read_as_truth_value(cursor: Cursor) -> bool:
+    node = cursor.value
+    parent = cursor.parent_tree_cursor()
+    while isinstance(parent.value, Parentheses):
+        node = parent.value
+        parent = parent.parent_tree_cursor()
+    value = parent.value
+    if isinstance(value, ControlParentheses):
+        return True
+    if isinstance(value, Unary):
+        return value.operator == Unary.Type.Not
+    if isinstance(value, Ternary):
+        return value.condition is node
+    if isinstance(value, Assert):
+        return value.condition is node
+    # `a or b` yields an operand, so its operands are truth values only if it is one.
+    if isinstance(value, JBinary) and value.operator in (JBinary.Type.And, JBinary.Type.Or):
+        return _is_read_as_truth_value(parent)
+    return False
+
 
 @categorize(_CodeQuality)
 class BooleanChecksNotInverted(Recipe):
@@ -71,7 +128,10 @@ class BooleanChecksNotInverted(Recipe):
         return (
             "Replace inverted boolean comparisons like `not (a == b)` with the "
             "equivalent direct operator (`a != b`), and remove double negations "
-            "like `not (not x)`."
+            "like `not (not x)`. An ordering such as `not (a < b)` is only "
+            "inverted where both operands' types resolve to numbers, a chained "
+            "comparison is left alone, and a double negation is only removed "
+            "where its value is read as a truth value, as in a condition."
         )
 
     @property
@@ -103,11 +163,15 @@ class BooleanChecksNotInverted(Recipe):
                     inner = inner.tree
 
                 # Double negation: not (not x) -> x
-                if isinstance(inner, Unary) and inner.operator == Unary.Type.Not:
+                if (
+                    isinstance(inner, Unary)
+                    and inner.operator == Unary.Type.Not
+                    and _is_read_as_truth_value(self.cursor)
+                ):
                     return inner.expression.replace(_prefix=unary.prefix)
 
                 # Inverted comparison: not (a == b) -> a != b
-                if isinstance(inner, JBinary):
+                if isinstance(inner, JBinary) and _is_invertible(inner):
                     inverse = _OPERATOR_INVERSE.get(inner.operator)
                     if inverse is not None:
                         return inner.padding.replace(

{openrewrite_migrate_python-0.16.0.dev20261006155312 → openrewrite_migrate_python-0.16.0.dev20261007033737}/src/openrewrite_code_quality_python/codequality/merge_identical_branches.py

@@ -19,13 +19,16 @@ from rewrite.markers import Markers
 from rewrite.python.visitor import PythonVisitor
 from rewrite.java.support_types import JLeftPadded, JRightPadded, Space
 from rewrite.java.tree import (
+    Assignment,
     Binary as JBinary,
     Block,
     ControlParentheses,
     Expression,
     If,
+    Lambda,
     Parentheses,
     Statement,
+    Ternary,
 )
 from openrewrite_code_quality_python.codequality._semantically_equal import SemanticallyEqual
 from rewrite.utils import random_id
@@ -36,8 +39,11 @@ _CodeQuality = [
 ]
 
 
-def _contains_and(expr: Expression) -> bool:
-    """Return True if the top-level expression is an ``and`` binary."""
+def _needs_parens_as_or_operand(expr: Expression) -> bool:
+    # A walrus, ternary or lambda binds looser than `or`. An `and` does not,
+    # and is parenthesized for readability.
+    if isinstance(expr, (Assignment, Ternary, Lambda)):
+        return True
     return isinstance(expr, JBinary) and expr.operator == JBinary.Type.And
 
 
@@ -160,8 +166,7 @@ def _merge_conditions(first: If, second: If) -> If:
     first_cond = first.if_condition.tree
     second_cond = second.if_condition.tree
 
-    # Wrap conditions in parens if they contain ``and`` to preserve precedence
-    if _contains_and(first_cond):
+    if _needs_parens_as_or_operand(first_cond):
         left = Parentheses(
             _id=random_id(),
             _prefix=first_cond.prefix,
@@ -175,7 +180,7 @@ def _merge_conditions(first: If, second: If) -> If:
     else:
         left = first_cond
 
-    if _contains_and(second_cond):
+    if _needs_parens_as_or_operand(second_cond):
         right = Parentheses(
             _id=random_id(),
             _prefix=Space.SINGLE_SPACE,

{openrewrite_migrate_python-0.16.0.dev20261006155312 → openrewrite_migrate_python-0.16.0.dev20261007033737}/src/openrewrite_code_quality_python/codequality/remove_duplicate_conditions.py

@@ -18,6 +18,7 @@ from rewrite.marketplace import Python
 from rewrite.python.visitor import PythonVisitor
 from rewrite.java.tree import If, Expression
 from openrewrite_code_quality_python.codequality._semantically_equal import SemanticallyEqual
+from openrewrite_code_quality_python.codequality._side_effects import is_side_effect_free
 
 _CodeQuality = [
     *Python,
@@ -79,7 +80,9 @@ class RemoveDuplicateConditions(Recipe):
         return (
             "Remove `elif` branches whose condition is identical to an earlier "
             "branch in the same `if`/`elif` chain, since the duplicate branch "
-            "is dead code that can never execute."
+            "is dead code that can never execute. A condition that may have "
+            "side effects, such as a call, is kept, since evaluating it again "
+            "can give a different result."
         )
 
     @property
@@ -136,7 +139,9 @@ def _prune_chain(root: If, current: If, seen: list[Expression]) -> If:
         return root
 
     cond = branch.if_condition.tree
-    is_dup = any(SemanticallyEqual.are_equal(cond, prev) for prev in seen)
+    is_dup = is_side_effect_free(cond) and any(
+        SemanticallyEqual.are_equal(cond, prev) for prev in seen
+    )
 
     if is_dup:
         # Skip this elif -- connect current to the duplicate's else

{openrewrite_migrate_python-0.16.0.dev20261006155312 → openrewrite_migrate_python-0.16.0.dev20261007033737}/src/openrewrite_code_quality_python/codequality/simplify_boolean_literal.py

@@ -16,7 +16,7 @@ from rewrite.decorators import categorize
 from rewrite.marketplace import Python
 from rewrite.markers import Markers
 from rewrite.python.visitor import PythonVisitor
-from rewrite.java.support_types import JLeftPadded, Space
+from rewrite.java.support_types import JavaType, JLeftPadded, Space
 from rewrite.java.tree import Binary as JBinary, Expression, Literal, Unary
 from rewrite.python.tree import Binary as PyBinary
 from rewrite.utils import random_id
@@ -81,7 +81,8 @@ class SimplifyBooleanLiteral(Recipe):
     def description(self) -> str:
         return (
             "Replace comparisons against boolean literals (`== True`, `!= False`, "
-            "`is True`, etc.) with the simpler equivalent boolean expression."
+            "`is True`, etc.) with the simpler equivalent boolean expression. "
+            "Only fires where the other operand's type resolves to `bool`."
         )
 
     @property
@@ -153,6 +154,9 @@ def _simplify_comparison(
         other = right
     if bool_val is None:
         return None
+    # `2 == True` is False, but `2` is truthy.
+    if other.type != JavaType.Primitive.Boolean:
+        return None
 
     # Determine whether the result should be negated.
     # == True  / is True  -> x        (identity)

{openrewrite_migrate_python-0.16.0.dev20261006155312 → openrewrite_migrate_python-0.16.0.dev20261007033737}/src/openrewrite_migrate_python/migrate/asyncio_coroutine_to_async.py

@@ -168,6 +168,27 @@ class _YieldFromToAwaitVisitor(PythonVisitor[ExecutionContext]):
         return lambda_
 
 
+class _BareYieldFinder(PythonVisitor[List[Yield]]):
+    """Collects each ``yield`` that is not a ``yield from``, outside nested functions."""
+
+    def visit_yield(self, yield_: Yield, p: List[Yield]) -> J:
+        if not isinstance(yield_.value, YieldFrom):
+            p.append(yield_)
+        return super().visit_yield(yield_, p)
+
+    def visit_method_declaration(self, method: MethodDeclaration, p: List[Yield]) -> J:
+        return method
+
+    def visit_lambda(self, lambda_: Lambda, p: List[Yield]) -> J:
+        return lambda_
+
+
+def _has_bare_yield(body: J) -> bool:
+    found: List[Yield] = []
+    _BareYieldFinder().visit(body, found)
+    return bool(found)
+
+
 @categorize(_Python311)
 class MigrateAsyncioCoroutine(Recipe):
     """
@@ -205,7 +226,8 @@ class MigrateAsyncioCoroutine(Recipe):
         return (
             "Migrate functions using the deprecated `@asyncio.coroutine` decorator "
             "to use `async def` syntax. Also transforms `yield from` to `await`. "
-            "The decorator was removed in Python 3.11."
+            "The decorator was removed in Python 3.11. A function whose body has "
+            "a bare `yield` is left alone, since it would become an async generator."
         )
 
     def editor(self) -> TreeVisitor[Any, ExecutionContext]:
@@ -219,6 +241,9 @@ class MigrateAsyncioCoroutine(Recipe):
 
                 if not _has_asyncio_coroutine_decorator(method):
                     return method
+                # A bare `yield` would make the `async def` an async generator.
+                if method.body is not None and _has_bare_yield(method.body):
+                    return method
 
                 # Step 1: Remove the @asyncio.coroutine decorator
                 method = _remove_asyncio_coroutine_decorator(method)

{openrewrite_migrate_python-0.16.0.dev20261006155312 → openrewrite_migrate_python-0.16.0.dev20261007033737}/src/openrewrite_migrate_python/migrate/string_formatting.py

@@ -19,9 +19,10 @@ from rewrite.decorators import categorize
 from rewrite.marketplace import Python
 from rewrite.markers import Markers
 from rewrite.python.visitor import PythonVisitor
-from rewrite.java.support_types import JRightPadded, Space
+from rewrite.java.support_types import JavaType, JRightPadded, Space
 from rewrite.java.tree import Binary, Expression, FieldAccess, Identifier, J, Literal, MethodInvocation, Parentheses
 from rewrite.python.printer import PrintOutputCapture, PythonPrinter
+from rewrite.python.type_utils import is_of_class_type
 from rewrite.python.tree import (
     CollectionLiteral,
     FormattedString,
@@ -126,6 +127,19 @@ def _is_side_effect_free(expr: Any) -> bool:
     return isinstance(expr, (Identifier, Literal, FieldAccess))
 
 
+_NON_TUPLE_BUILTINS = ("list", "dict", "set", "frozenset")
+
+
+def _resolves_to_non_tuple(expr: Expression) -> bool:
+    # A tuple operand is spread over the specifiers, so `"%s" % (1,)` is `"1"`.
+    # A class's supertypes may stop short of `tuple`, as a NamedTuple's do,
+    # so only types known not to be tuples qualify.
+    type_ = expr.type
+    return isinstance(type_, JavaType.Primitive) or any(
+        is_of_class_type(type_, name) for name in _NON_TUPLE_BUILTINS
+    )
+
+
 def _has_backslash(value_source: str) -> bool:
     """Check if the string content (between quotes) contains a backslash."""
     s = value_source
@@ -470,8 +484,10 @@ def _convert_percent_to_fstring(binary: Binary) -> Optional[FormattedString]:
     # Get argument list
     if isinstance(right, CollectionLiteral) and right.kind == CollectionLiteral.Kind.TUPLE:
         args = list(right.elements)
-    else:
+    elif isinstance(right, Expression) and _resolves_to_non_tuple(right):
         args = [right]
+    else:
+        return None
 
     # Verify arg count matches specifier count
     if len(args) != spec_count:
@@ -560,7 +576,9 @@ class ReplacePercentFormatWithFString(Recipe):
         return (
             'Replace `"..." % (...)` expressions with f-strings (Python 3.6+). '
             "Only converts `%s` and `%r` specifiers where the format string is "
-            "a literal and the conversion is safe."
+            "a literal and the conversion is safe. A single operand that is not a "
+            "tuple literal must have a type that resolves to a non-tuple, such as "
+            "`str` or `int`, since a tuple would be spread over the specifiers."
         )
 
     @property

{openrewrite_migrate_python-0.16.0.dev20261006155312 → openrewrite_migrate_python-0.16.0.dev20261007033737}/src/openrewrite_migrate_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.16.0.dev20261006155312
+Version: 0.16.0.dev20261007033737
 Summary: OpenRewrite recipes for migrating Python codebases to newer Python versions.
 Author-email: "Moderne Inc." <support@moderne.io>
 License: Moderne Proprietary

{openrewrite_migrate_python-0.16.0.dev20261006155312 → openrewrite_migrate_python-0.16.0.dev20261007033737}/src/openrewrite_migrate_python.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ src/openrewrite_code_quality_python/__init__.py
 src/openrewrite_code_quality_python/codequality/__init__.py
 src/openrewrite_code_quality_python/codequality/_reindent.py
 src/openrewrite_code_quality_python/codequality/_semantically_equal.py
+src/openrewrite_code_quality_python/codequality/_side_effects.py
 src/openrewrite_code_quality_python/codequality/_trivia.py
 src/openrewrite_code_quality_python/codequality/all_branches_identical.py
 src/openrewrite_code_quality_python/codequality/boolean_checks_not_inverted.py

{openrewrite_migrate_python-0.16.0.dev20261006155312 → openrewrite_migrate_python-0.16.0.dev20261007033737}/tests/test_asyncio_coroutine_to_async.py

@@ -167,6 +167,7 @@ class TestMigrateAsyncioCoroutine:
                 @asyncio.coroutine
                 def outer():
                     def gen():
+                        yield 0
                         yield from range(3)
                     g = lambda: (yield from range(3))
                     yield from step()
@@ -176,9 +177,35 @@ class TestMigrateAsyncioCoroutine:
 
                 async def outer():
                     def gen():
+                        yield 0
                         yield from range(3)
                     g = lambda: (yield from range(3))
                     await step()
                 """,
             )
         )
+
+    def test_no_change_when_the_body_has_a_bare_yield(self):
+        spec = RecipeSpec(recipe=MigrateAsyncioCoroutine())
+        spec.rewrite_run(
+            python(
+                """
+                import asyncio
+
+                @asyncio.coroutine
+                def f():
+                    yield
+                """
+            ),
+
+            python(
+                """
+                import asyncio
+
+                @asyncio.coroutine
+                def g():
+                    x = yield from step()
+                    yield x
+                """
+            ),
+        )

{openrewrite_migrate_python-0.16.0.dev20261006155312 → openrewrite_migrate_python-0.16.0.dev20261007033737}/tests/test_string_formatting.py

@@ -1,5 +1,7 @@
 """Tests for string formatting recipes."""
 
+import pytest
+
 from rewrite import InMemoryExecutionContext, InMemoryLargeSourceSet, Recipe
 from rewrite.test import RecipeSpec, python
 from openrewrite_migrate_python.migrate.string_formatting import (
@@ -370,18 +372,54 @@ class TestReplaceStrFormatWithFString:
 class TestReplacePercentFormatWithFString:
     """Tests for the ReplacePercentFormatWithFString recipe."""
 
+    @pytest.mark.requires_type_attribution
     def test_simple_percent_s(self):
         """'Hello %s' % name → f'Hello {name}'"""
         spec = RecipeSpec(recipe=ReplacePercentFormatWithFString())
         spec.rewrite_run(
             python(
                 """
+                name = "world"
                 message = "Hello %s" % name
                 """,
                 """
+                name = "world"
                 message = f"Hello {name}"
                 """,
-            )
+            ),
+
+            python(
+                """
+                items = [1]
+                message = "Hello %s" % items
+                """,
+                """
+                items = [1]
+                message = f"Hello {items}"
+                """,
+            ),
+        )
+
+    def test_no_change_unless_a_single_operand_resolves_to_a_non_tuple(self):
+        spec = RecipeSpec(recipe=ReplacePercentFormatWithFString())
+        spec.rewrite_run(
+            python(
+                """
+                t = (1,)
+                message = "%s" % t
+                """
+            ),
+
+            python(
+                """
+                from typing import NamedTuple
+                class P(NamedTuple):
+                    x: int
+                message = "%s" % P(1)
+                """
+            ),
+
+            python('message = "Hello %s" % name'),
         )
 
     def test_multiple_percent_s(self):
@@ -398,43 +436,52 @@ class TestReplacePercentFormatWithFString:
             )
         )
 
+    @pytest.mark.requires_type_attribution
     def test_percent_r(self):
         """'%r' % x → f'{x!r}'"""
         spec = RecipeSpec(recipe=ReplacePercentFormatWithFString())
         spec.rewrite_run(
             python(
                 """
+                x = 1
                 message = "%r" % x
                 """,
                 """
+                x = 1
                 message = f"{x!r}"
                 """,
             )
         )
 
+    @pytest.mark.requires_type_attribution
     def test_escaped_percent(self):
         """'100%% of %s' % name → f'100% of {name}'"""
         spec = RecipeSpec(recipe=ReplacePercentFormatWithFString())
         spec.rewrite_run(
             python(
                 """
+                name = "world"
                 message = "100%% of %s" % name
                 """,
                 """
+                name = "world"
                 message = f"100% of {name}"
                 """,
             )
         )
 
+    @pytest.mark.requires_type_attribution
     def test_single_quotes(self):
         """'Hello %s' % name → f'Hello {name}' (single quotes)"""
         spec = RecipeSpec(recipe=ReplacePercentFormatWithFString())
         spec.rewrite_run(
             python(
                 """
+                name = "world"
                 message = 'Hello %s' % name
                 """,
                 """
+                name = "world"
                 message = f'Hello {name}'
                 """,
             )
@@ -556,6 +603,7 @@ class TestReplacePercentFormatWithFString:
             )
         )
 
+    @pytest.mark.requires_type_attribution
     def test_idempotent(self):
         """Running the recipe twice produces the same result."""
         recipe = ReplacePercentFormatWithFString()
@@ -563,9 +611,11 @@ class TestReplacePercentFormatWithFString:
         spec.rewrite_run(
             python(
                 """
+                name = "world"
                 message = "Hello %s" % name
                 """,
                 """
+                name = "world"
                 message = f"Hello {name}"
                 """,
                 after_recipe=_assert_idempotent(recipe),