openrewrite-migrate-python 0.15.0.dev20260922170519__tar.gz → 0.15.1__tar.gz

{openrewrite_migrate_python-0.15.0.dev20260922170519 → openrewrite_migrate_python-0.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.15.0.dev20260922170519
+Version: 0.15.1
 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.15.0.dev20260922170519 → openrewrite_migrate_python-0.15.1}/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.15.0.dev20260922170519"  # Updated dynamically during release
+version = "0.15.1"  # Updated dynamically during release
 authors = [{ name = "Moderne Inc.", email = "support@moderne.io" }]
 license = { text = "Moderne Proprietary" }
 readme = "README.md"

{openrewrite_migrate_python-0.15.0.dev20260922170519 → openrewrite_migrate_python-0.15.1}/src/openrewrite_code_quality_python/codequality/__init__.py

@@ -2,6 +2,7 @@
 
 from .all_branches_identical import AllBranchesIdentical
 from .boolean_checks_not_inverted import BooleanChecksNotInverted
+from .code_quality import CodeQuality
 from .collapsible_if_statements import CollapsibleIfStatements
 from .merge_identical_branches import MergeIdenticalBranches
 from .remove_duplicate_conditions import RemoveDuplicateConditions
@@ -13,6 +14,7 @@ from .simplify_redundant_logical_expression import SimplifyRedundantLogicalExpre
 __all__ = [
     "AllBranchesIdentical",
     "BooleanChecksNotInverted",
+    "CodeQuality",
     "CollapsibleIfStatements",
     "MergeIdenticalBranches",
     "RemoveDuplicateConditions",

openrewrite_migrate_python-0.15.1/src/openrewrite_code_quality_python/codequality/code_quality.py

@@ -0,0 +1,73 @@
+"""Composite recipe bundling the Python code quality fixes."""
+
+from typing import List
+
+from rewrite import Recipe
+from rewrite.category import CategoryDescriptor
+from rewrite.decorators import categorize
+from rewrite.marketplace import Python
+
+from .all_branches_identical import AllBranchesIdentical
+from .boolean_checks_not_inverted import BooleanChecksNotInverted
+from .collapsible_if_statements import CollapsibleIfStatements
+from .merge_identical_branches import MergeIdenticalBranches
+from .remove_duplicate_conditions import RemoveDuplicateConditions
+from .remove_self_assignment import RemoveSelfAssignment
+from .remove_unconditional_value_overwrite import RemoveUnconditionalValueOverwrite
+from .simplify_boolean_literal import SimplifyBooleanLiteral
+from .simplify_redundant_logical_expression import SimplifyRedundantLogicalExpression
+
+_CodeQuality = [
+    *Python,
+    CategoryDescriptor(display_name="Code quality"),
+]
+
+
+@categorize(_CodeQuality)
+class CodeQuality(Recipe):
+    """
+    Apply every Python code quality fix.
+
+    Example:
+        Before:
+            if done == True:
+                if ready:
+                    run()
+
+        After:
+            if done and ready:
+                run()
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.codequality.CodeQuality"
+
+    @property
+    def display_name(self) -> str:
+        return "Code quality"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Apply all Python code quality recipes that change code: simplify boolean "
+            "expressions, merge and collapse `if` chains, and remove dead conditions and "
+            "writes. Search-only recipes, which mark code for review, are not included."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "code-quality"]
+
+    def recipe_list(self) -> List[Recipe]:
+        return [
+            SimplifyBooleanLiteral(),
+            BooleanChecksNotInverted(),
+            SimplifyRedundantLogicalExpression(),
+            RemoveDuplicateConditions(),
+            AllBranchesIdentical(),
+            MergeIdenticalBranches(),
+            CollapsibleIfStatements(),
+            RemoveSelfAssignment(),
+            RemoveUnconditionalValueOverwrite(),
+        ]

openrewrite_migrate_python-0.15.1/src/openrewrite_code_quality_python/codequality/remove_unconditional_value_overwrite.py

@@ -0,0 +1,333 @@
+"""
+Recipe to remove dict entry writes that the next statement overwrites.
+
+See: https://rules.sonarsource.com/python/RSPEC-S4143/
+"""
+
+from itertools import islice
+from typing import Any, List, Optional, Tuple
+
+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.method_matcher import MethodMatcher
+from rewrite.python.visitor import PythonVisitor
+from rewrite.python.tree import (
+    CollectionLiteral,
+    CompilationUnit,
+    ComprehensionExpression,
+    DictLiteral,
+    ExpressionStatement,
+    KeyValue,
+    NamedArgument,
+    TypeHintedExpression,
+    VariableScope,
+)
+from rewrite.java.support_types import Space
+from rewrite.java.tree import (
+    ArrayAccess,
+    Assignment,
+    Block,
+    ClassDeclaration,
+    Empty,
+    Expression,
+    Identifier,
+    J,
+    Lambda,
+    Literal,
+    MethodDeclaration,
+    MethodInvocation,
+    Parentheses,
+    Statement,
+    Try,
+    Unary,
+)
+from openrewrite_code_quality_python.codequality._semantically_equal import SemanticallyEqual
+from openrewrite_code_quality_python.codequality._trivia import splice_out, split_line
+
+_CodeQuality = [
+    *Python,
+    CategoryDescriptor(display_name="Code quality"),
+]
+
+
+def _get_assignment(stmt: Statement) -> Optional[Assignment]:
+    """Extract an Assignment from a statement, if present."""
+    if isinstance(stmt, ExpressionStatement):
+        expr = stmt.expression
+        if isinstance(expr, Assignment):
+            return expr
+    if isinstance(stmt, Assignment):
+        return stmt
+    return None
+
+
+class _Find(PythonVisitor[None]):
+    """Records whether any subtree of the visited node satisfies ``predicate``."""
+
+    def __init__(self, predicate):
+        super().__init__()
+        self._predicate = predicate
+        self.found = False
+
+    def visit(self, tree, p, parent=None):
+        if tree is not None and self._predicate(tree):
+            self.found = True
+        return super().visit(tree, p, parent)
+
+
+def _contains(node, predicate) -> bool:
+    search = _Find(predicate)
+    search.visit(node, None)
+    return search.found
+
+
+def _mentions(node, name: str) -> bool:
+    return _contains(node, lambda n: isinstance(n, Identifier) and n.simple_name == name)
+
+
+def _is_number(expression: J) -> bool:
+    return (
+        isinstance(expression, Unary)
+        and expression.operator in (Unary.Type.Negative, Unary.Type.Positive)
+        and isinstance(expression.expression, Literal)
+        and isinstance(expression.expression.value, (int, float, complex))
+    )
+
+
+def _is_hashable_constant(expression: J) -> bool:
+    """A value whose hashing and comparison run no user code and cannot raise."""
+    if isinstance(expression, Parentheses) and isinstance(expression.tree, Expression):
+        return _is_hashable_constant(expression.tree)
+    if isinstance(expression, Literal) or _is_number(expression):
+        return True
+    return (
+        isinstance(expression, CollectionLiteral)
+        and expression.kind == CollectionLiteral.Kind.TUPLE
+        and all(_is_hashable_constant(e) for e in expression.elements if not isinstance(e, Empty))
+    )
+
+
+def _is_constant(expression: J) -> bool:
+    """A value whose evaluation runs no user code and cannot raise."""
+    if isinstance(expression, Parentheses) and isinstance(expression.tree, Expression):
+        return _is_constant(expression.tree)
+    if isinstance(expression, CollectionLiteral):
+        element_ok = _is_hashable_constant if expression.kind == CollectionLiteral.Kind.SET else _is_constant
+        return all(element_ok(e) for e in expression.elements if not isinstance(e, Empty))
+    if isinstance(expression, DictLiteral):
+        return all(
+            isinstance(e, KeyValue) and _is_hashable_constant(e.key) and _is_constant(e.value)
+            for e in expression.elements
+            if not isinstance(e, Empty)
+        )
+    return _is_hashable_constant(expression)
+
+
+def _store(stmt: Statement) -> Optional[Tuple[str, Expression, Expression]]:
+    """The dict name, key and value of a ``d[key] = value`` statement with a constant key."""
+    assign = _get_assignment(stmt)
+    if assign is None or not isinstance(assign.variable, ArrayAccess):
+        return None
+    receiver = assign.variable.indexed
+    key = assign.variable.dimension.index
+    if not isinstance(receiver, Identifier) or not _is_hashable_constant(key):
+        return None
+    return receiver.simple_name, key, assign.assignment
+
+
+_DICT_CONSTRUCTOR = MethodMatcher.create("dict <constructor>(..)")
+
+
+def _builds_dict(value: Expression) -> bool:
+    """True when ``value`` is a new builtin dict holding only constant keys."""
+    if isinstance(value, DictLiteral):
+        return all(
+            isinstance(e, KeyValue) and _is_hashable_constant(e.key)
+            for e in value.elements
+            if not isinstance(e, Empty)
+        )
+    return (
+        isinstance(value, MethodInvocation)
+        and _DICT_CONSTRUCTOR.matches(value)
+        and all(isinstance(a, (NamedArgument, Empty)) for a in value.arguments)
+    )
+
+
+def _binds_fresh_dict(stmt: Statement, name: str) -> bool:
+    assign = _get_assignment(stmt)
+    if assign is None:
+        return False
+    variable = assign.variable
+    if isinstance(variable, TypeHintedExpression):
+        variable = variable.expression
+    return (
+        isinstance(variable, Identifier)
+        and variable.simple_name == name
+        and _builds_dict(assign.assignment)
+    )
+
+
+def _is_fresh_at(statements: List[Statement], i: int, name: str) -> bool:
+    """True when ``name`` holds a dict this block built and has kept to itself up to ``i``.
+
+    Rebinding the dict on every pass through the block keeps it fresh in a
+    loop too.  Only constant-key stores may touch it in between, so every key
+    it holds hashes and compares without running user code.
+    """
+    for stmt in reversed(statements[:i]):
+        if _binds_fresh_dict(stmt, name):
+            return True
+        store = _store(stmt)
+        if store is not None and store[0] == name and not _mentions(store[2], name):
+            continue
+        if _mentions(stmt, name):
+            return False
+    return False
+
+
+_NESTED_SCOPES = (ClassDeclaration, ComprehensionExpression, Lambda, MethodDeclaration)
+
+
+def _shared_beyond_frame(function: MethodDeclaration, name: str) -> bool:
+    """True when ``name`` in ``function`` is a global, or a cell a nested scope can read."""
+    return _contains(
+        function.body,
+        lambda n: (
+            isinstance(n, VariableScope) and any(i.simple_name == name for i in n.names)
+        ) or (isinstance(n, _NESTED_SCOPES) and _mentions(n, name)),
+    )
+
+
+def _enclosing_function(cursor: Cursor) -> Optional[MethodDeclaration]:
+    """The function whose frame alone can observe a block's locals, if there is one.
+
+    A ``try`` or ``with`` between them can catch an exception and read the
+    dict afterwards, so a block inside one has no such function.
+    """
+    for value in islice(cursor.get_path(), 1, None):
+        if isinstance(value, MethodDeclaration):
+            return value
+        if isinstance(value, (Try, ClassDeclaration, CompilationUnit)):
+            return None
+    return None
+
+
+def _is_dead_write(statements: List[Statement], i: int, function: MethodDeclaration) -> bool:
+    """True when the write at ``i`` is overwritten by the next one before anything can see it.
+
+    The dict has to be one only this frame can reach, which rules out other
+    threads, aliases reached through a call, and setter hooks.  The dropped
+    value has to be a constant, so dropping it drops no code.
+    """
+    a = _store(statements[i])
+    b = _store(statements[i + 1])
+    if a is None or b is None:
+        return False
+    name, key, value = a
+    return (
+        b[0] == name
+        and SemanticallyEqual.are_equal(key, b[1])
+        and _is_constant(value)
+        and not _mentions(b[2], name)
+        and _is_fresh_at(statements, i, name)
+        and not _shared_beyond_frame(function, name)
+    )
+
+
+@categorize(_CodeQuality)
+class RemoveUnconditionalValueOverwrite(Recipe):
+    """
+    Remove a dict entry write that the next statement overwrites.
+
+    Only a dict the function has just built and kept to itself qualifies.
+
+    Example:
+        Before:
+            def f():
+                d = {}
+                d["key"] = 1
+                d["key"] = 2
+                return d
+
+        After:
+            def f():
+                d = {}
+                d["key"] = 2
+                return d
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.codequality.RemoveUnconditionalValueOverwrite"
+
+    @property
+    def display_name(self) -> str:
+        return "Remove unconditional value overwrites"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Remove a constant written to a dict key when the next statement "
+            "overwrites the same key. Only a dict the enclosing function built "
+            "with `{...}` or `dict()` and has not yet passed on qualifies, and "
+            "only for constant keys outside `try` and `with` blocks. Writes to "
+            "attributes, parameters and globals are left alone, because "
+            "another thread, an alias or a setter can observe them."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "code-quality", "RSPEC-S4143"]
+
+    @property
+    def estimated_effort_per_occurrence(self) -> int:
+        return 5
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_block(
+                self, block: Block, p: ExecutionContext
+            ) -> Optional[Block]:
+                block = super().visit_block(block, p)
+                if not isinstance(block, Block):
+                    return block
+                function = _enclosing_function(self.cursor)
+                if function is None:
+                    return block
+                removed = _remove_overwrites(block._statements, block.end, function)
+                if removed is not None:
+                    return block.replace(_statements=removed[0], _end=removed[1])
+                return block
+
+        return Visitor()
+
+
+def _removable(padded_statements: list, i: int, function: MethodDeclaration) -> bool:
+    """Return True when the write at ``i`` is dead and can be dropped by splicing lines.
+
+    Both the write and its overwrite have to start a line of their own,
+    which a `;`-joined pair does not.
+    """
+    if i + 1 >= len(padded_statements):
+        return False
+    statements = [s.element for s in padded_statements]
+    if not _is_dead_write(statements, i, function):
+        return False
+    if split_line(statements[i].prefix) is None:
+        return False
+    return split_line(statements[i + 1].prefix) is not None
+
+
+def _remove_overwrites(
+    padded_statements: list, end: Space, function: MethodDeclaration
+) -> Optional[Tuple[list, Space]]:
+    """Return the statements and end trivia with dead writes removed, or None if unchanged."""
+    to_remove = {
+        i for i in range(len(padded_statements))
+        if _removable(padded_statements, i, function)
+    }
+    if not to_remove:
+        return None
+    return splice_out(padded_statements, end, to_remove)

{openrewrite_migrate_python-0.15.0.dev20260922170519 → openrewrite_migrate_python-0.15.1}/src/openrewrite_migrate_python/migrate/string_formatting.py

@@ -21,10 +21,9 @@ from rewrite.markers import Markers
 from rewrite.python.visitor import PythonVisitor
 from rewrite.java.support_types import 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.tree import (
     CollectionLiteral,
-    ComprehensionExpression,
-    DictLiteral,
     FormattedString,
     NamedArgument,
     Star,
@@ -74,17 +73,6 @@ def _get_fstring_delimiter(value_source: str) -> Optional[str]:
     return 'f' + quote if quote else None
 
 
-def _opens_with_brace(expr: Any) -> bool:
-    """Whether ``expr`` prints with a leading ``{`` that the field's own brace makes into ``{{``."""
-    if isinstance(expr, DictLiteral):
-        return True
-    if isinstance(expr, CollectionLiteral):
-        return expr.kind == CollectionLiteral.Kind.SET
-    if isinstance(expr, ComprehensionExpression):
-        return expr.kind in (ComprehensionExpression.Kind.SET, ComprehensionExpression.Kind.DICT)
-    return False
-
-
 def _breaks_replacement_field(expr: Any, quote: str) -> bool:
     """Whether ``expr`` holds anything a replacement field cannot carry.
 
@@ -124,11 +112,11 @@ def _unsafe_to_interpolate(expr: Any, delimiter: str) -> bool:
     """Whether substituting ``expr`` into a replacement field spoils the f-string.
 
     A literal argument nests a string in a string, a rewrite worth declining however it
-    is quoted. Deeper literals are declined only where 3.8 -- the earliest target these
-    recipes run for -- cannot parse the result.
+    is quoted. Other expressions are declined only where 3.8 -- the earliest target
+    these recipes run for -- cannot parse the result.
     """
     value = expr.value if isinstance(expr, NamedArgument) else expr
-    if _opens_with_brace(value) or _is_string_literal(value):
+    if _is_string_literal(value):
         return True
     return _breaks_replacement_field(value, delimiter[1:])
 
@@ -151,6 +139,23 @@ def _has_backslash(value_source: str) -> bool:
     return '\\' in content
 
 
+def _field_expression(arg_expr: Expression, delimiter: str) -> Optional[JRightPadded]:
+    """The argument as a replacement field, or None when it cannot sit inside this f-string."""
+    expr = arg_expr.replace(_prefix=Space.EMPTY)
+    source = PythonPrinter().print(expr, PrintOutputCapture(None))
+    # Only legal in a replacement field from 3.12 (PEP 701)
+    if any(c in source for c in (delimiter[1], '\\', '#', '\n')):
+        return None
+    # A leading or trailing brace would fuse with the field's own and read as an escaped brace
+    if source.startswith('{'):
+        expr = expr.replace(_prefix=Space.SINGLE_SPACE)
+    return JRightPadded(
+        _element=expr,
+        _after=Space.SINGLE_SPACE if source.endswith('}') else Space.EMPTY,
+        _markers=Markers.EMPTY,
+    )
+
+
 def _convert_format_to_fstring(method: MethodInvocation) -> Optional[FormattedString]:
     """Convert a ``"...".format(...)`` MethodInvocation to a FormattedString.
 
@@ -267,11 +272,9 @@ def _convert_format_to_fstring(method: MethodInvocation) -> Optional[FormattedSt
                     return None
                 arg_expr = named_args[field_name]
 
-            padded_expr = JRightPadded(
-                _element=arg_expr.replace(_prefix=Space.EMPTY),
-                _after=Space.EMPTY,
-                _markers=Markers.EMPTY,
-            )
+            padded_expr = _field_expression(arg_expr, delimiter)
+            if padded_expr is None:
+                return None
 
             # Map conversion flag
             conversion_enum = None
@@ -301,9 +304,9 @@ def _convert_format_to_fstring(method: MethodInvocation) -> Optional[FormattedSt
                 _markers=Markers.EMPTY,
                 _expression=padded_expr,
                 _debug=None,
-                _conversion=conversion_enum,
+                _conversion=None,
                 _format=format_node,
-            ))
+            ).with_conversion(conversion_enum))
 
     return FormattedString(
         _id=random_id(),
@@ -498,11 +501,9 @@ def _convert_percent_to_fstring(binary: Binary) -> Optional[FormattedString]:
             arg_expr = args[arg_index]
             arg_index += 1
 
-            padded_expr = JRightPadded(
-                _element=arg_expr.replace(_prefix=Space.EMPTY),
-                _after=Space.EMPTY,
-                _markers=Markers.EMPTY,
-            )
+            padded_expr = _field_expression(arg_expr, delimiter)
+            if padded_expr is None:
+                return None
 
             conversion_enum = None
             if part_value == 'r':
@@ -514,9 +515,9 @@ def _convert_percent_to_fstring(binary: Binary) -> Optional[FormattedString]:
                 _markers=Markers.EMPTY,
                 _expression=padded_expr,
                 _debug=None,
-                _conversion=conversion_enum,
+                _conversion=None,
                 _format=None,
-            ))
+            ).with_conversion(conversion_enum))
 
     return FormattedString(
         _id=random_id(),

{openrewrite_migrate_python-0.15.0.dev20260922170519 → openrewrite_migrate_python-0.15.1}/src/openrewrite_migrate_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.15.0.dev20260922170519
+Version: 0.15.1
 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.15.0.dev20260922170519 → openrewrite_migrate_python-0.15.1}/src/openrewrite_migrate_python.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ src/openrewrite_code_quality_python/codequality/_semantically_equal.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
+src/openrewrite_code_quality_python/codequality/code_quality.py
 src/openrewrite_code_quality_python/codequality/collapsible_if_statements.py
 src/openrewrite_code_quality_python/codequality/find_suspicious_chained_comparison.py
 src/openrewrite_code_quality_python/codequality/merge_identical_branches.py

{openrewrite_migrate_python-0.15.0.dev20260922170519 → openrewrite_migrate_python-0.15.1}/tests/test_string_formatting.py

@@ -249,6 +249,31 @@ class TestReplaceStrFormatWithFString:
             )
         )
 
+    def test_set_literal_argument_is_spaced_from_the_field_braces(self):
+        """A brace of the argument's own must not fuse with the field's into an escaped brace."""
+        spec = RecipeSpec(recipe=ReplaceStrFormatWithFString())
+        spec.rewrite_run(
+            python(
+                """
+                message = "{} outside {} block".format(op, {'for', 'while'})
+                """,
+                """
+                message = f"{op} outside { {'for', 'while'} } block"
+                """,
+            )
+        )
+
+    def test_no_change_argument_contains_the_delimiter_quote(self):
+        """The quote is only legal inside a replacement field from 3.12."""
+        spec = RecipeSpec(recipe=ReplaceStrFormatWithFString())
+        spec.rewrite_run(
+            python(
+                """
+                message = "{} outside {} block".format(op, {"for", "while"})
+                """,
+            )
+        )
+
     def test_no_change_backslash_in_string(self):
         """'hello\\n{}'.format(name) — backslash escape, no change."""
         spec = RecipeSpec(recipe=ReplaceStrFormatWithFString())
@@ -326,19 +351,6 @@ class TestReplaceStrFormatWithFString:
             )
         )
 
-    def test_no_change_brace_opening_argument(self):
-        """A brace-opening argument's own brace would read as an escaped `{{`."""
-        spec = RecipeSpec(recipe=ReplaceStrFormatWithFString())
-        spec.rewrite_run(
-            python(
-                """
-                keywords = "{}".format({1, 2})
-                mapping = "{}".format({1: 2})
-                squares = "{}".format({n: n * n for n in sizes})
-                """
-            )
-        )
-
     def test_idempotent(self):
         """Running the recipe twice produces the same result."""
         recipe = ReplaceStrFormatWithFString()
@@ -485,6 +497,29 @@ class TestReplacePercentFormatWithFString:
             )
         )
 
+    def test_dict_literal_argument_is_spaced_from_the_field_braces(self):
+        spec = RecipeSpec(recipe=ReplacePercentFormatWithFString())
+        spec.rewrite_run(
+            python(
+                """
+                message = "config: %s" % ({'a': 1},)
+                """,
+                """
+                message = f"config: { {'a': 1} }"
+                """,
+            )
+        )
+
+    def test_no_change_argument_contains_the_delimiter_quote(self):
+        spec = RecipeSpec(recipe=ReplacePercentFormatWithFString())
+        spec.rewrite_run(
+            python(
+                """
+                message = "name: %s" % d["name"]
+                """,
+            )
+        )
+
     def test_no_change_backslash(self):
         r"""'%s\n' % x — backslash in string, no change."""
         spec = RecipeSpec(recipe=ReplacePercentFormatWithFString())