openrewrite-migrate-python 0.19.0__py3-none-any.whl → 0.20.0__py3-none-any.whl

openrewrite_code_quality_python/cleanup/boolean_simplification.py

@@ -14,7 +14,8 @@ unnecessary operators, literals, or indirection:
 See: https://peps.python.org/pep-0008/#programming-recommendations
 """
 
-from typing import Any, List
+from typing import AbstractSet, Any, Dict, List, NamedTuple, Tuple
+from uuid import UUID
 
 from rewrite import ExecutionContext, Preconditions, Recipe, TreeVisitor
 from rewrite.markers import Markers
@@ -28,11 +29,11 @@ from rewrite.python.preconditions import uses_method
 from rewrite.python.scope_utils import scope_of
 from rewrite.python.type_utils import is_of_class_type
 from rewrite.python.visitor import PythonVisitor
-from rewrite.python.template import pattern, template, capture
+from rewrite.python.template import Capture, Template, pattern, template, capture
 from rewrite.python.template.pattern import MatchResult
 from rewrite.java.tree import (
     Binary as JBinary, Block, ControlParentheses, Empty, Expression, If as JIf, J,
-    Literal, MethodInvocation, Return, Ternary as JTernary, Unary,
+    Literal, MethodInvocation, Parentheses, Return, Ternary as JTernary, Unary,
     WhileLoop as JWhileLoop,
 )
 from rewrite.java.support_types import JavaType, Space
@@ -80,22 +81,43 @@ _lc_not_x_template = template("not {lc_x}", lc_x=_lc_x)
 
 
 # --- DeMorgan patterns/templates ---
+class _Distributed(NamedTuple):
+    """A De Morgan result, written alone or continuing a chain of its own operator."""
+
+    alone: Template
+    chained: Template
+    """``{dm_z} and`` the result, which the parser nests to the left as it does ``z and a and b``."""
+    operator: JBinary.Type
+
+
+_dm_z = capture('dm_z')
+
+
+def _distributed(operator: str, left: str, right: str, captures: Dict[str, Capture]) -> _Distributed:
+    return _Distributed(
+        Template(f"{left} {operator} {right}", captures),
+        Template(f"{{dm_z}} {operator} {left} {operator} {right}", {'dm_z': _dm_z, **captures}),
+        JBinary.Type.And if operator == "and" else JBinary.Type.Or,
+    )
+
+
 _dm_x = capture('dm_x')
 _dm_y = capture('dm_y')
+_dm_xy = {'dm_x': _dm_x, 'dm_y': _dm_y}
 _not_and_pattern = pattern("not ({dm_x} and {dm_y})", dm_x=_dm_x, dm_y=_dm_y)
 _not_or_pattern = pattern("not ({dm_x} or {dm_y})", dm_x=_dm_x, dm_y=_dm_y)
-_not_x_or_not_y_template = template("not {dm_x} or not {dm_y}", dm_x=_dm_x, dm_y=_dm_y)
-_not_x_and_not_y_template = template("not {dm_x} and not {dm_y}", dm_x=_dm_x, dm_y=_dm_y)
+_not_x_or_not_y = _distributed("or", "not {dm_x}", "not {dm_y}", _dm_xy)
+_not_x_and_not_y = _distributed("and", "not {dm_x}", "not {dm_y}", _dm_xy)
 # Partial-negation templates: one operand already negated by operator flip (in→not in)
-_not_x_or_y_template = template("not {dm_x} or {dm_y}", dm_x=_dm_x, dm_y=_dm_y)
-_x_or_not_y_template = template("{dm_x} or not {dm_y}", dm_x=_dm_x, dm_y=_dm_y)
-_not_x_and_y_template = template("not {dm_x} and {dm_y}", dm_x=_dm_x, dm_y=_dm_y)
-_x_and_not_y_template = template("{dm_x} and not {dm_y}", dm_x=_dm_x, dm_y=_dm_y)
+_not_x_or_y = _distributed("or", "not {dm_x}", "{dm_y}", _dm_xy)
+_x_or_not_y = _distributed("or", "{dm_x}", "not {dm_y}", _dm_xy)
+_not_x_and_y = _distributed("and", "not {dm_x}", "{dm_y}", _dm_xy)
+_x_and_not_y = _distributed("and", "{dm_x}", "not {dm_y}", _dm_xy)
 # Fused DeMorgan + double-negation: not (not x and not y) -> x or y
 _not_notx_and_noty_pattern = pattern("not (not {dm_x} and not {dm_y})", dm_x=_dm_x, dm_y=_dm_y)
-_x_or_y_template = template("{dm_x} or {dm_y}", dm_x=_dm_x, dm_y=_dm_y)
+_x_or_y = _distributed("or", "{dm_x}", "{dm_y}", _dm_xy)
 _not_notx_or_noty_pattern = pattern("not (not {dm_x} or not {dm_y})", dm_x=_dm_x, dm_y=_dm_y)
-_x_and_y_template = template("{dm_x} and {dm_y}", dm_x=_dm_x, dm_y=_dm_y)
+_x_and_y = _distributed("and", "{dm_x}", "{dm_y}", _dm_xy)
 
 # DeMorgan with comparison operators: not (p == q and r == s) -> p != q or r != s
 _dm_p = capture('dm_p')
@@ -105,8 +127,8 @@ _dm_s = capture('dm_s')
 _not_eq_and_eq_pattern = pattern(
     "not ({dm_p} == {dm_q} and {dm_r} == {dm_s})", dm_p=_dm_p, dm_q=_dm_q, dm_r=_dm_r, dm_s=_dm_s
 )
-_neq_or_neq_template = template(
-    "{dm_p} != {dm_q} or {dm_r} != {dm_s}", dm_p=_dm_p, dm_q=_dm_q, dm_r=_dm_r, dm_s=_dm_s
+_neq_or_neq = _distributed(
+    "or", "{dm_p} != {dm_q}", "{dm_r} != {dm_s}", {'dm_p': _dm_p, 'dm_q': _dm_q, 'dm_r': _dm_r, 'dm_s': _dm_s}
 )
 
 def _is_bool_literal(node, expected_source: str) -> bool:
@@ -299,8 +321,11 @@ class RemoveRedundantBoolean(Recipe):
         return Visitor()
 
 
-def _apply_demorgan(cursor, match, truth_value, both_not, left_not, right_not, neither_not):
-    """Apply a DeMorgan template, folding negations where possible.
+_Distribution = Tuple[_Distributed, MatchResult]
+
+
+def _choose_demorgan(match, truth_value, both_not, left_not, right_not, neither_not) -> _Distribution | None:
+    """Choose a DeMorgan template and its values, folding negations where possible.
 
     For each operand, tries to absorb the ``not`` introduced by DeMorgan:
 
@@ -319,19 +344,58 @@ def _apply_demorgan(cursor, match, truth_value, both_not, left_not, right_not, n
     y_negated = negated_without_not(dm_y_val, truth_value)
 
     if x_negated and y_negated:
-        values = MatchResult({'dm_x': x_negated, 'dm_y': y_negated})
-        return neither_not.apply(cursor, values=values)
+        return neither_not, MatchResult({'dm_x': x_negated, 'dm_y': y_negated})
     if x_negated:
-        values = MatchResult({'dm_x': x_negated, 'dm_y': dm_y_val})
-        return right_not.apply(cursor, values=values)
+        return right_not, MatchResult({'dm_x': x_negated, 'dm_y': dm_y_val})
     if y_negated:
-        values = MatchResult({'dm_x': dm_x_val, 'dm_y': y_negated})
-        return left_not.apply(cursor, values=values)
-    return both_not.apply(cursor, values=match)
+        return left_not, MatchResult({'dm_x': dm_x_val, 'dm_y': y_negated})
+    return both_not, match
+
+
+def _negated_chain(unary: Unary, operator: JBinary.Type) -> JBinary | None:
+    """The parenthesized chain of three or more ``operator`` operands that ``unary`` negates, or None."""
+    inner = unary.expression
+    if isinstance(inner, Parentheses):
+        inner = inner.tree
+    if isinstance(inner, JBinary) and inner.operator == operator \
+            and isinstance(inner.left, JBinary) and inner.left.operator == operator:
+        return inner
+    return None
+
+
+def _operands(chain: Expression, operator: JBinary.Type) -> List[Expression]:
+    """The operands of ``chain``, a chain of ``operator`` nested to the left."""
+    operands = []
+    while isinstance(chain, JBinary) and chain.operator == operator:
+        operands.append(chain.right)
+        chain = chain.left
+    return [chain, *operands]
+
+
+def _distributes(unary: Unary, written: Unary, made: AbstractSet[UUID], operator: JBinary.Type,
+                 truth_value: bool) -> bool:
+    """Whether ``unary``'s ``not`` distributes over its ``operator``: never over a chain ``written`` spells, unless
+    ``made`` holds it, and over a chain a rewrite made only where each operand can be negated."""
+    spelled = _negated_chain(written, operator)
+    if spelled is not None and spelled.id not in made:
+        return False
+    chain = _negated_chain(unary, operator)
+    return chain is None or truth_value or not any(is_not(operand) for operand in _operands(chain, operator))
+
 
+def _and_head(made: AbstractSet[UUID], unary: Unary, distributed: _Distributed) -> AbstractSet[UUID]:
+    """``made`` and the left part of the chain ``unary`` negates, which ``distributed`` negates whole."""
+    negated = JBinary.Type.And if distributed.operator == JBinary.Type.Or else JBinary.Type.Or
+    chain = _negated_chain(unary, negated)
+    return made if chain is None else made | {chain.left.id}
 
-def _distribute_not(unary: Unary, cursor: Cursor) -> J:
-    """``unary`` with its ``not`` distributed one level in, or ``unary`` itself."""
+
+def _distribution(unary: Unary, cursor: Cursor, written: Unary, made: AbstractSet[UUID]) -> _Distribution | None:
+    """How ``unary``'s ``not`` distributes one level in, or None where it does not.
+
+    ``written`` is ``unary`` as the code spells it, before its operands were rewritten, and ``made`` holds the ids
+    of the chains that rewrites made.
+    """
     truth_value = is_read_as_truth_value(cursor)
 
     # not (p == q and r == s) -> p != q or r != s
@@ -340,46 +404,52 @@ def _distribute_not(unary: Unary, cursor: Cursor) -> J:
         isinstance(operand, Expression) and is_comparison(operand)
         for operand in (match[k] for k in ('dm_p', 'dm_q', 'dm_r', 'dm_s'))
     ):
-        if not truth_value:
-            return unary
-        return _neq_or_neq_template.apply(cursor, values=match) or unary
+        return (_neq_or_neq, match) if truth_value else None
 
     if truth_value:
         # Fused: not (not x and not y) -> x or y
         match = _not_notx_and_noty_pattern.match(unary, cursor)
         if match:
-            return _x_or_y_template.apply(cursor, values=match) or unary
+            return _x_or_y, match
 
         # Fused: not (not x or not y) -> x and y
         match = _not_notx_or_noty_pattern.match(unary, cursor)
         if match:
-            return _x_and_y_template.apply(cursor, values=match) or unary
+            return _x_and_y, match
 
     # not (x and y) -> not x or not y
-    # Skip multi-way chains: not (a and b and c) where dm_x
-    # captures (a and b) — partial expansion is messy.
+    # A chain the code spells, as not (a and b and c), is left alone, but one that rewriting an operand
+    # made distributes: not (a or not (b and c)) has become not (a or not b or not c) by now.
     match = _not_and_pattern.match(unary, cursor)
-    if match:
-        dm_x_val = match['dm_x']
-        if not (isinstance(dm_x_val, JBinary) and dm_x_val.operator == JBinary.Type.And):
-            return _apply_demorgan(
-                cursor, match, truth_value, _not_x_or_not_y_template,
-                _not_x_or_y_template, _x_or_not_y_template,
-                _x_or_y_template,
-            ) or unary
+    if match and _distributes(unary, written, made, JBinary.Type.And, truth_value):
+        return _choose_demorgan(match, truth_value, _not_x_or_not_y, _not_x_or_y, _x_or_not_y, _x_or_y)
 
     # not (x or y) -> not x and not y
     match = _not_or_pattern.match(unary, cursor)
-    if match:
-        dm_x_val = match['dm_x']
-        if not (isinstance(dm_x_val, JBinary) and dm_x_val.operator == JBinary.Type.Or):
-            return _apply_demorgan(
-                cursor, match, truth_value, _not_x_and_not_y_template,
-                _not_x_and_y_template, _x_and_not_y_template,
-                _x_and_y_template,
-            ) or unary
+    if match and _distributes(unary, written, made, JBinary.Type.Or, truth_value):
+        return _choose_demorgan(match, truth_value, _not_x_and_not_y, _not_x_and_y, _x_and_not_y, _x_and_y)
+
+    return None
+
+
+def _ends_chain(cursor: Cursor, operator: JBinary.Type) -> bool:
+    """Whether the value at ``cursor`` is the right operand of an ``and``/``or`` of ``operator``."""
+    node, parent = cursor.value, cursor.parent_tree_cursor().value
+    return isinstance(node, J) and isinstance(parent, JBinary) and parent.operator == operator \
+        and parent.right.id == node.id
+
 
-    return unary
+def _respaced(chain: J, binary: JBinary) -> J:
+    """``chain``, written by a template in place of ``binary``, with the spaces and comments ``binary`` had
+    around its left operand and its operator."""
+    head = chain.left if isinstance(chain, JBinary) else None
+    if not isinstance(head, JBinary):
+        return chain
+    return chain.replace(_left=head.replace(
+        _left=head.left.replace(_prefix=binary.left.prefix),
+        _operator=binary.padding.operator,
+        _right=head.right.replace(_prefix=binary.right.prefix),
+    ))
 
 
 @categorize(_Cleanup)
@@ -423,6 +493,11 @@ class DeMorgan(Recipe):
 
     def editor(self) -> TreeVisitor[Any, ExecutionContext]:
         class Visitor(PythonVisitor[ExecutionContext]):
+            def __init__(self, made: AbstractSet[UUID] = frozenset()):
+                super().__init__()
+                # The ids of chains that rewrites made, which this visit meets again in what a template wrote.
+                self._made = made
+
             def visit_unary(
                 self, unary: Unary, p: ExecutionContext
             ) -> J:
@@ -431,11 +506,38 @@ class DeMorgan(Recipe):
                     visited.replace(_prefix=Space.EMPTY)
                 ):
                     return visited
-                result = _distribute_not(visited, Cursor(self.cursor.parent, visited))
-                if result is visited:
+                cursor = Cursor(self.cursor.parent, visited)
+                distribution = _distribution(visited, cursor, unary, self._made)
+                # The `and` holding `x and not (a or b)` rewrites it whole, in visit_binary.
+                if distribution is None or _ends_chain(cursor, distribution[0].operator):
+                    return visited
+                distributed, values = distribution
+                result = distributed.alone.apply(cursor, values=values)
+                if result is None:
                     return visited
                 # The negations a rewrite creates may distribute in turn.
-                return Visitor().visit(result, p, self.cursor.parent_or_throw) or result
+                made = _and_head(self._made, visited, distributed)
+                return Visitor(made).visit(result, p, self.cursor.parent_or_throw) or result
+
+            def visit_binary(self, binary: JBinary, p: ExecutionContext) -> J:
+                visited = super().visit_binary(binary, p)
+                if not isinstance(visited, JBinary) or not isinstance(visited.right, Unary) or has_comments(
+                    visited.right.replace(_prefix=Space.EMPTY)
+                ):
+                    return visited
+                cursor = Cursor(self.cursor.parent, visited)
+                # Read under the unvisited `and`/`or`, as visit_unary read it before leaving it here.
+                written = binary.right if isinstance(binary.right, Unary) else visited.right
+                distribution = _distribution(visited.right, Cursor(self.cursor, visited.right), written, self._made)
+                if distribution is None or distribution[0].operator != visited.operator:
+                    return visited
+                distributed, values = distribution
+                result = distributed.chained.apply(cursor, values={**values.as_dict(), 'dm_z': visited.left})
+                if result is None:
+                    return visited
+                result = _respaced(result, visited)
+                made = _and_head(self._made, visited.right, distributed)
+                return Visitor(made).visit(result, p, self.cursor.parent_or_throw) or result
 
         return Visitor()
 

openrewrite_code_quality_python/cleanup/pandas_cleanup.py

@@ -9,6 +9,7 @@ Both fire only where the receiver's pandas type resolves.
 See: https://pandas.pydata.org/docs/whatsnew/v1.4.0.html#deprecations
 """
 
+import dataclasses
 from typing import Any, List
 
 from rewrite import ExecutionContext, Preconditions, Recipe, TreeVisitor
@@ -103,12 +104,19 @@ class DataframeAppendToConcat(Recipe):
                 ):
                     return m
                 try:
-                    return _concat_template.apply(
+                    concat = _concat_template.apply(
                         self.cursor, visitor=self, values={'df': select, 'x': args[0]}
-                    ) or m
+                    )
                 except ValueError:
                     # The template refuses a file where `pd` is bound to something else.
                     return m
+                if not isinstance(concat, MethodInvocation):
+                    return concat or m
+                # Typed as the receiver, so that an `append` on this result or taking it is migrated too.
+                method_type = concat.method_type
+                if method_type is None:
+                    return concat
+                return concat.replace(_method_type=dataclasses.replace(method_type, _return_type=select.type))
 
         # `append` does not resolve under pandas 2, so the gate names the receiver.
         return Preconditions.check(uses_type(_DATAFRAME), Visitor())

openrewrite_code_quality_python/codequality/_grouping.py

@@ -0,0 +1,31 @@
+"""Grouping an ``and`` or ``or`` chain the way the parser groups it."""
+
+from rewrite.java.support_types import Space
+from rewrite.java.tree import Binary
+from rewrite.utils import random_id
+
+from openrewrite_code_quality_python.codequality._trivia import concat
+
+_CHAINED = (Binary.Type.And, Binary.Type.Or)
+
+
+def grouped_left(binary: Binary) -> Binary:
+    """``binary`` with a chain of its own operator on its right, unparenthesized, regrouped to the left.
+
+    ``a and (b and c)`` without the parentheses prints as ``a and b and c``, which the parser
+    groups as ``(a and b) and c``. Both evaluate the same, but a recipe matching the tree sees
+    other operands in each.
+    """
+    right = binary.right
+    if binary.operator not in _CHAINED or not isinstance(right, Binary) or right.operator != binary.operator:
+        return binary
+    left = binary.replace(
+        _id=random_id(),
+        _prefix=Space.EMPTY,
+        _right=right.left.replace(_prefix=concat(right.prefix, right.left.prefix)),
+    )
+    return grouped_left(binary.replace(
+        _left=grouped_left(left),
+        _operator=right.padding.operator,
+        _right=right.right,
+    ))

openrewrite_code_quality_python/codequality/collapsible_if_statements.py

@@ -28,6 +28,7 @@ from rewrite.java.tree import (
 )
 from rewrite.utils import random_id
 
+from openrewrite_code_quality_python.codequality._grouping import grouped_left
 from openrewrite_code_quality_python.codequality._reindent import (
     line_indent,
     reindent,
@@ -190,8 +191,12 @@ class CollapsibleIfStatements(Recipe):
                     ),
                     _type=None,
                 )
-                combined = combined.replace(
+                # An `and` chain in the inner condition continues the merged one, nested to the left
+                # as the parser nests `a and b and c`, so only its last operand is left to parenthesize.
+                combined = grouped_left(combined.replace(
                     _left=maybe_parenthesize(combined, combined.left.id, combined.left),
+                ))
+                combined = combined.replace(
                     _right=maybe_parenthesize(combined, combined.right.id, combined.right),
                 )
 

openrewrite_code_quality_python/codequality/merge_identical_branches.py

@@ -27,6 +27,7 @@ from rewrite.java.tree import (
     If,
     Statement,
 )
+from openrewrite_code_quality_python.codequality._grouping import grouped_left
 from openrewrite_code_quality_python.codequality._semantically_equal import SemanticallyEqual
 from rewrite.utils import random_id
 
@@ -180,8 +181,12 @@ def _merge_conditions(first: If, second: If) -> If:
         _right=_or_operand(second_cond, Space.SINGLE_SPACE),
         _type=None,
     )
-    combined = combined.replace(
+    # An `or` chain in the second condition continues the merged one, nested to the left as the
+    # parser nests `a or b or c`, so only its last operand is left to parenthesize.
+    combined = grouped_left(combined.replace(
         _left=maybe_parenthesize(combined, combined.left.id, combined.left),
+    ))
+    combined = combined.replace(
         _right=maybe_parenthesize(combined, combined.right.id, combined.right),
     )
 

openrewrite_migrate_python/migrate/_method_renames.py

@@ -19,16 +19,22 @@ def rename_methods(
     method gives it. The patterns match overrides, since a call through a subclass to a member
     typeshed no longer declares resolves to the subclass.
     """
-    patterns = {old: f"{declaring_type} {old}(..)" for old in renames}
-    calls = {old: MethodMatcher.create(pattern, match_overrides=True) for old, pattern in patterns.items()}
+    # Where Python still declares `old` as an alias, `old = new`, the call resolves to `new`.
+    patterns = {
+        old: [f"{declaring_type} {old}(..)", f"{declaring_type} {new}(..)"] for old, new in renames.items()
+    }
+    calls = {
+        old: [MethodMatcher.create(pattern, match_overrides=True) for pattern in alternatives]
+        for old, alternatives in patterns.items()
+    }
 
     class Visitor(PythonVisitor[ExecutionContext]):
         def visit_method_invocation(self, method: MethodInvocation, p: ExecutionContext) -> J:
             m = super().visit_method_invocation(method, p)
             if not isinstance(m, MethodInvocation):
                 return m
-            call = calls.get(m.name.simple_name)
-            if call is None or not call.matches(m, cursor=self.cursor):
+            matchers = calls.get(m.name.simple_name, [])
+            if not any(matcher.matches(m, cursor=self.cursor) for matcher in matchers):
                 return m
             # The old method type names the old method, which no longer describes the call.
             m = m.replace(
@@ -41,7 +47,9 @@ def rename_methods(
             ]
             return m.padding.replace(_arguments=arguments.padding.replace(elements=elements))
 
-    gates = [uses_method(pattern, match_overrides=True) for pattern in patterns.values()]
+    gates = [
+        uses_method(pattern, match_overrides=True) for alternatives in patterns.values() for pattern in alternatives
+    ]
     return Preconditions.check(gates[0] if len(gates) == 1 else Preconditions.or_(*gates), Visitor())
 
 

openrewrite_migrate_python/migrate/backoff_to_tenacity.py

@@ -55,7 +55,7 @@ from rewrite.java.tree import (
     Annotation, Assignment, Binary, ClassDeclaration, Empty, Expression, FieldAccess,
     Identifier, Import, J,
     JLeftPadded, JRightPadded, Literal, Lambda, MethodDeclaration, MethodInvocation, Modifier,
-    Space, Statement,
+    Parentheses, Space, Statement,
 )
 from rewrite.rpc import RpcRecipe
 
@@ -485,18 +485,18 @@ class _Settings:
     dict in another module, so nothing can be read off the decorator alone.
     """
 
-    # module name -> dict name -> keyword -> value expression.
-    dicts: Dict[str, Dict[str, Dict[str, Expression]]] = field(default_factory=dict)
+    # module name -> dict name -> the dict literal's text, which a lookup parses again.
+    dicts: Dict[str, Dict[str, str]] = field(default_factory=dict)
     # Names assigned more than once, or mutated, whose contents nothing can rely on.
     unsafe: Set[Tuple[str, str]] = field(default_factory=set)
 
-    def record(self, module: str, name: str, entries: Dict[str, Expression] | None) -> None:
+    def record(self, module: str, name: str, source: str | None) -> None:
         known = self.dicts.setdefault(module, {})
-        if name in known or entries is None:
+        if name in known or source is None:
             # A second binding of the name, or one whose value is not a plain literal dict.
             self.unsafe.add((module, name))
             return
-        known[name] = entries
+        known[name] = source
 
     def mutated(self, module: str, name: str) -> None:
         self.unsafe.add((module, name))
@@ -504,7 +504,9 @@ class _Settings:
     def lookup(self, module: str, name: str) -> Dict[str, Expression] | None:
         if (module, name) in self.unsafe:
             return None
-        return self.dicts.get(module, {}).get(name)
+        source = self.dicts.get(module, {}).get(name)
+        parsed = _parsed_expression(source) if source is not None else None
+        return _dict_entries(parsed) if parsed is not None else None
 
 
 def _module_name(path: PurePosixPath) -> str:
@@ -543,15 +545,13 @@ class _Compat:
     package_dirs: Set[str] = field(default_factory=set)
     # Files already holding a compat module, so a second run does not write it again.
     existing: Set[str] = field(default_factory=set)
-    # The helpers each file's converted decorators call, worked out in `generate`: a
-    # decorator splatting a dict from another module cannot be read until every file is in.
+    # The helpers each file's converted decorators call, read off each decorator in the scan
+    # except one splatting a dict, which `generate` reads once every module's dicts are in.
     needed: Dict[str, Set[str]] = field(default_factory=dict)
-    # The decorators each file holds, with what its imports bound when they were seen.
-    pending: Dict[str, List[Tuple[Annotation, "_Bindings", bool]]] = field(
+    # Those splatting decorators, each as the member invoked, the text of its call, what the
+    # file's imports bound and whether it decorates an `async def`.
+    splatted: Dict[str, List[Tuple[str | None, str, "_Bindings", bool]]] = field(
         default_factory=dict)
-    # The same for the ones written as a call rather than with an `@`, with the member invoked.
-    pending_calls: Dict[str, List[Tuple[str, MethodInvocation, "_Bindings", bool]]] \
-        = field(default_factory=dict)
     settings: _Settings = field(default_factory=_Settings)
     # Filled in by `generate`, read by the editor: the module a file imports its helpers from.
     module_of: Dict[str, str] = field(default_factory=dict)
@@ -584,6 +584,32 @@ def _parsed_module(source: str, path: PurePosixPath) -> SourceFile:
     return cu.replace(_source_path=Path(str(path)))
 
 
+def _source_of(tree: J, cursor: Cursor) -> str:
+    """``tree``'s text without its prefix or the markup of its markers, which an accumulator keeps
+    in place of the tree."""
+    return tree.replace(prefix=Space.EMPTY).print(cursor, PrintOutputCapture(
+        0, PrintOutputCapture.MarkerPrinter.SANITIZED))  # ty: ignore[too-many-positional-arguments]
+
+
+def _call_source(call: Annotation | MethodInvocation, cursor: Cursor) -> str:
+    """The text of the call a decorator makes, ``@`` or not, which parses as a call either way."""
+    source = _source_of(call, cursor)
+    return source.removeprefix("@").lstrip() if isinstance(call, Annotation) else source
+
+
+def _parsed_expression(source: str) -> Expression | None:
+    """The expression ``source`` spells, parsed on its own in parentheses, which let it span lines
+    as the brackets around it in its file did."""
+    from rewrite.python._parser_visitor import ParserVisitor
+
+    text = f"({source})"
+    statements = ParserVisitor(text, None, None).visit_Module(ast.parse(text)).statements
+    statement = statements[0] if len(statements) == 1 else None
+    expression = statement.expression if isinstance(statement, ExpressionStatement) else statement
+    inner = expression.tree if isinstance(expression, Parentheses) else None
+    return inner if isinstance(inner, Expression) else None
+
+
 _COMPAT_DOCSTRING = """The parts of backoff that tenacity has no equivalent for.
 
 Written by org.openrewrite.python.migrate.MigrateBackoffToTenacity.
@@ -819,6 +845,11 @@ def _split_arguments(
     return positional, named
 
 
+def _splats(call: Annotation | MethodInvocation) -> bool:
+    """Whether ``call`` has a ``**`` argument, which only the run's settings dicts can read."""
+    return any(isinstance(a, Star) and a.kind == Star.Kind.DICT for a in call.arguments or [])
+
+
 def _splat_entries(
     expression: Expression, bindings: "_Bindings", settings: _Settings,
 ) -> Dict[str, Expression] | None:
@@ -1300,6 +1331,7 @@ class _VendorMembers(PythonVisitor[None]):
 
 def _collect_settings(cu: CompilationUnit, settings: _Settings, module: str) -> None:
     """Record this module's top-level dict literals, and what it rules out relying on."""
+    cursor = Cursor(Cursor(None, Cursor.ROOT_VALUE), cu)
     for statement in cu.statements:
         expression = statement.expression if isinstance(statement, ExpressionStatement) \
             else statement
@@ -1312,7 +1344,9 @@ def _collect_settings(cu: CompilationUnit, settings: _Settings, module: str) ->
             # Only a module-level constant is worth reading: anything else is far likelier
             # to be built up or rebound somewhere this never looks.
             continue
-        settings.record(module, name, _dict_entries(expression.assignment))
+        value = expression.assignment
+        settings.record(module, name,
+                        _source_of(value, cursor) if _dict_entries(value) is not None else None)
 
     # A mutation anywhere in the file, or a rebinding below the top level, means the dict
     # a decorator splats is not the dict seen here.
@@ -1670,11 +1704,12 @@ class ReplaceBackoffDecoratorsWithTenacity(ScanningRecipe[_Compat]):
                 visited = super().visit_annotation(annotation, p)
                 if not isinstance(visited, Annotation):
                     return visited
-                # Only recorded here: a decorator cannot be read until every module's
-                # settings dicts are in, which is not until the whole scan is done.
-                if self._bindings.binds_anything() and self.is_backoff(visited):
-                    acc.pending.setdefault(self._path, []).append(
-                        (visited, self._bindings, _decorates_async(self.cursor)))
+                outcome = self.outcome(visited)
+                if outcome is not None and _splats(visited):
+                    self._defer(self._bindings.resolve(visited.annotation_type), visited,
+                                _decorates_async(self.cursor))
+                else:
+                    ReplaceBackoffDecoratorsWithTenacity._record_helpers(acc, self._path, outcome)
                 return visited
 
             # A member used as a value or a type is rewritten without any analysis, but the
@@ -1692,28 +1727,34 @@ class ReplaceBackoffDecoratorsWithTenacity(ScanningRecipe[_Compat]):
                 self, method: MethodInvocation, p: ExecutionContext,
             ) -> J:
                 self._record(self.vendored_call(method))
-                decorator = _invoked_member(method, self._bindings)
-                if decorator in _DECORATORS and not self._shadowed_call(method) \
-                        and self.cursor.first_enclosing(Annotation) is None:
-                    acc.pending_calls.setdefault(self._path, []).append(
-                        (decorator, method, self._bindings, self._wraps_async()))
+                outcome = self.call_outcome(method)
+                if outcome is not None and _splats(method):
+                    self._defer(_invoked_member(method, self._bindings), method, self._wraps_async())
+                else:
+                    ReplaceBackoffDecoratorsWithTenacity._record_helpers(acc, self._path, outcome)
                 return super().visit_method_invocation(method, p)
 
             def _record(self, found: Tuple[str, str, bool] | None) -> None:
                 if found is not None:
                     acc.needed.setdefault(self._path, set()).add(found[0])
 
+            def _defer(
+                self, decorator: str | None, call: Annotation | MethodInvocation, is_async: bool,
+            ) -> None:
+                # The dict a `**` names may be in a module the scan has not reached yet, so the
+                # decorator is read in `generate`, from its text.
+                acc.splatted.setdefault(self._path, []).append(
+                    (decorator, _call_source(call, self.cursor), self._bindings, is_async))
+
         return Scanner()
 
     def generate(self, acc: _Compat, ctx: ExecutionContext) -> List[SourceFile]:
-        for path, decorators in acc.pending.items():
-            for annotation, bindings, is_async in decorators:
-                self._record_helpers(
-                    acc, path, _analyze(annotation, bindings, is_async, acc.settings))
-        for path, calls in acc.pending_calls.items():
-            for decorator, call, bindings, is_async in calls:
-                self._record_helpers(acc, path, _analyze_call(
-                    decorator, call, bindings, is_async, acc.settings))
+        for path, calls in acc.splatted.items():
+            for decorator, source, bindings, is_async in calls:
+                call = _parsed_expression(source)
+                if isinstance(call, MethodInvocation):
+                    self._record_helpers(acc, path, _analyze_call(
+                        decorator, call, bindings, is_async, acc.settings))
 
         helpers: Dict[PurePosixPath, Set[str]] = {}
         for path, needed in sorted(acc.needed.items()):

{openrewrite_migrate_python-0.19.0.dist-info → openrewrite_migrate_python-0.20.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.19.0
+Version: 0.20.0
 Summary: OpenRewrite recipes for migrating Python codebases to newer Python versions.
 Author-email: "Moderne Inc." <support@moderne.io>
 License: Moderne Proprietary
@@ -19,7 +19,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Provides-Extra: dev
-Requires-Dist: openrewrite>=8.94.0; extra == "dev"
+Requires-Dist: openrewrite>=8.96.3; extra == "dev"
 Requires-Dist: pydantic>=2.11; extra == "dev"
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

{openrewrite_migrate_python-0.19.0.dist-info → openrewrite_migrate_python-0.20.0.dist-info}/RECORD

@@ -4,7 +4,7 @@ openrewrite_code_quality_python/cleanup/_literals.py,sha256=bv-dN0v-FOLBIHEqxNHw
 openrewrite_code_quality_python/cleanup/_negation.py,sha256=dMIzjStSrDKK80txkClEklWBMr5a1-boT5WjWRwtQp4,1704
 openrewrite_code_quality_python/cleanup/assign_return.py,sha256=y10YG2MkcZoE0Ded_0UPBLt-mg7omkRS4D3AP67v06I,5352
 openrewrite_code_quality_python/cleanup/attr_access.py,sha256=V3gRlZkXac34q4t2aAKIRc8xRzl3t8GAqPpY69883cg,8491
-openrewrite_code_quality_python/cleanup/boolean_simplification.py,sha256=esv83CBNIc25jkKM2bZisjmpMdsb69z4t7d0pzvaVUY,33924
+openrewrite_code_quality_python/cleanup/boolean_simplification.py,sha256=8CpM8CPUDvy2BfilgHL7BkeJ7bbhvoDR6m6EpeWNoF4,39167
 openrewrite_code_quality_python/cleanup/collection_literals.py,sha256=uFFIOZ_PFqRXkyesrXf368xVGKuGb7hK94Zf24rH3wo,15866
 openrewrite_code_quality_python/cleanup/comparison_simplification.py,sha256=lhXIy_UMWeDRGyBZJnLFzN0em_ij6cRuWFgm6dS050A,13114
 openrewrite_code_quality_python/cleanup/complex_transforms.py,sha256=oEKdO9bzvvJipFzfVDANtGqnYoFSs7J_vuZd5TZjUHo,10690
@@ -22,7 +22,7 @@ openrewrite_code_quality_python/cleanup/naming_conventions.py,sha256=qqZuF5b8lVr
 openrewrite_code_quality_python/cleanup/negated_operators.py,sha256=DOXtB249IlPJovRNpCJPYHcv79u8bnNlwesqWRfJePg,5097
 openrewrite_code_quality_python/cleanup/none_and_identity.py,sha256=QVdFo9MdsF1RHGWLmR4179qAeYCEn99a-OJ8rEn9PBM,12092
 openrewrite_code_quality_python/cleanup/object_inheritance.py,sha256=7hy16CBEUNTRoXYuWqe0_ZZS5Ig4Yft6VTErkWpIfkc,3099
-openrewrite_code_quality_python/cleanup/pandas_cleanup.py,sha256=-A5IdSOO4AC1GTtt1nPXfRspatHkkW0TZV2gFU_2FY4,8080
+openrewrite_code_quality_python/cleanup/pandas_cleanup.py,sha256=2eq7R5Cux9RTFCChaclSr0KIfAdn_SmW1wwB0Bmqj7g,8536
 openrewrite_code_quality_python/cleanup/python_best_practices.py,sha256=AkJa4Wr02cqKhlAsfr7yDKOUpSHkw8ljuj6uxLrF9-A,9309
 openrewrite_code_quality_python/cleanup/range_cleanup.py,sha256=9KFNSiiSc2pl_S6KdpUW_Hhtw9zweOAT393Zth72ids,5287
 openrewrite_code_quality_python/cleanup/redundant_code.py,sha256=aMPAAOO5uhBZy1j5o2LvX3lKD6Q3KuDKx1G0b_Mv5uk,6812
@@ -33,6 +33,7 @@ openrewrite_code_quality_python/cleanup/use_items.py,sha256=_ifgqhSga2uXhOBYcGgi
 openrewrite_code_quality_python/cleanup/use_list_clear.py,sha256=XXfAbF6suxfvby4QbqWtiCtw6yMIH__6mSleNomoiXQ,4294
 openrewrite_code_quality_python/cleanup/yoda_conditions.py,sha256=hk3nNoUPSJK4NoX18F5wggvmHbrVjHUNUL9WMqqJR8Y,4551
 openrewrite_code_quality_python/codequality/__init__.py,sha256=ctQ0xAuLLSuLZoVajxaW2zn0RPm3VD-iCrLGx0XFZZY,1124
+openrewrite_code_quality_python/codequality/_grouping.py,sha256=9WPdgX_9RELDoz4wRw0uO-yB6cO2snb6RTlBermYWUQ,1165
 openrewrite_code_quality_python/codequality/_reindent.py,sha256=ZeD2DOqQtYAKc0v21JtBg_jqxKpg39ur9kcVV8gWtt4,3514
 openrewrite_code_quality_python/codequality/_semantically_equal.py,sha256=tdkYMvtxoOQuoqY1Jx1we5NiCCPFV_5oKtEDpSJejkI,1649
 openrewrite_code_quality_python/codequality/_side_effects.py,sha256=p-xvunfN8bUGXpTmt1DHOA1P2moPSkR1aVgqg52hUEc,1227
@@ -41,9 +42,9 @@ openrewrite_code_quality_python/codequality/_truth_value.py,sha256=T52Aznr8ZUnL7
 openrewrite_code_quality_python/codequality/all_branches_identical.py,sha256=Qx4oBBE_MJvCpZVIlmMmP_9USL8SLUznnFheqEoZdbY,7943
 openrewrite_code_quality_python/codequality/boolean_checks_not_inverted.py,sha256=cGqCcP1e5FChahREpJ6YBHhwEVwlQDWWE9ukOzaKTi4,6582
 openrewrite_code_quality_python/codequality/code_quality.py,sha256=qO_et2buzzQi2yVZtA2ncIaZ129PuaruPOWyB3GgwMQ,2284
-openrewrite_code_quality_python/codequality/collapsible_if_statements.py,sha256=1uTVpE-gX6KUNSKyAbWfzouWfq0FXi0FNPP1WjNdwqE,9197
+openrewrite_code_quality_python/codequality/collapsible_if_statements.py,sha256=Dc2U5jxxwb38Er7GbVMKd8iJ__eT1K3Agu2-F7q4wvM,9559
 openrewrite_code_quality_python/codequality/find_suspicious_chained_comparison.py,sha256=oe3YEtM6FgiHl9nX2jq0rmZzQ_M7BcOaD13PHlSCGM8,3720
-openrewrite_code_quality_python/codequality/merge_identical_branches.py,sha256=VLFzk7BH_YSvUy5JTbwNRiN0su4ViysUwHEUKqWiQng,6847
+openrewrite_code_quality_python/codequality/merge_identical_branches.py,sha256=fIVc1EHEo6tCIfF4YyU_CdBOaE-QMyhj_OfUd0vHM1I,7159
 openrewrite_code_quality_python/codequality/remove_duplicate_conditions.py,sha256=DgoD3w3zqEIrcHukYEsXOlp5ksG5EhVxa1zW0LeczdM,6588
 openrewrite_code_quality_python/codequality/remove_self_assignment.py,sha256=8jyrmh5P9kXwaR9f8Nb0ZapwrksWSXXlhMpMQY_kabE,7519
 openrewrite_code_quality_python/codequality/remove_unconditional_value_overwrite.py,sha256=t9AUeuJr--iQnfKOv65ewxTFXPQxPsjA7YOcV7cAGRo,11982
@@ -55,7 +56,7 @@ openrewrite_migrate_python/migrate/_decorators.py,sha256=03DZoAa3LQ9fXZx3FFm_RSm
 openrewrite_migrate_python/migrate/_finders.py,sha256=RVmkMUOWLxxCWx4Ig8SUEbqPTVGqrAP2VVhiazBsCyM,4960
 openrewrite_migrate_python/migrate/_langchain_tables.py,sha256=TF2A2iwkULa5uybo1rBxp_o2weziCxAmn5NLUcSAXqs,55153
 openrewrite_migrate_python/migrate/_markers.py,sha256=EggMUANYXPh0Q6GbKlhWpthC0ac5VtgEbyHVLGyeH4Y,1126
-openrewrite_migrate_python/migrate/_method_renames.py,sha256=mmsaSugVo2gi9dA4-IlTbKZo6PZQ7251ngVFsKHAlfw,2587
+openrewrite_migrate_python/migrate/_method_renames.py,sha256=-6xpdU5u8xkvAO65TjVnPXblqYi8jA-Pl2_Mm6f6480,2869
 openrewrite_migrate_python/migrate/_module_imports.py,sha256=kSuccPhiCcrVYhGelQOWJ2UZkN2YHNDiMP-QDK5En98,2844
 openrewrite_migrate_python/migrate/_slots.py,sha256=WYiAMYa7_tZE3vI_r55kMBojHXdxE58CzvhyAOJSZ48,634
 openrewrite_migrate_python/migrate/aifc_migrations.py,sha256=FxEUdhNFGm-7oNTrvk76eDy6wTjA9uRSjdOrwQ5oT-I,8900
@@ -64,7 +65,7 @@ openrewrite_migrate_python/migrate/ast_deprecations.py,sha256=fudnnAwQfBU5YCOe37
 openrewrite_migrate_python/migrate/asyncio_coroutine_to_async.py,sha256=l4HOVWAaVY_7Deunjr8cGLWQ07CLyZqclFjiPDJSz_I,9471
 openrewrite_migrate_python/migrate/asyncio_deprecations.py,sha256=6lliBj-lvRthCs1CuN4A-Z5iQlkQQ9C6vKxi59ErCwg,11327
 openrewrite_migrate_python/migrate/avro_migrations.py,sha256=6wb2_zFYTXEiK_DZ_Jl3awsMMG6GpZ6PJWZuer0DqG4,2331
-openrewrite_migrate_python/migrate/backoff_to_tenacity.py,sha256=5QA8gSWhY05pwLrkxQhjrCT19FlxpA1BN4h1up-y41s,91995
+openrewrite_migrate_python/migrate/backoff_to_tenacity.py,sha256=Ob6s32hwxL5XU4_yidyX0PlOp_z-mJWUAdBwIeos4uA,94033
 openrewrite_migrate_python/migrate/builtins_deprecations.py,sha256=cWFmqa2GPUTZgk6O_sDDDMVfT1PfBCU615FkTQmtAQw,5625
 openrewrite_migrate_python/migrate/calendar_deprecations.py,sha256=EPDRqN7Uf6U41CjfZu6BiJDZ4ehaNlBgzZD4YxGFzWs,2417
 openrewrite_migrate_python/migrate/cgi_escape_deprecations.py,sha256=Alevj5BrJ59wOd2dQRlorKypLZSS4b1FG9YV8FteCR4,8595
@@ -144,8 +145,8 @@ openrewrite_migrate_python/migrate/wave_deprecations.py,sha256=QcjcFNpb2mQ4v8VdY
 openrewrite_migrate_python/migrate/webbrowser_deprecations.py,sha256=2ENvVuz5fcKAxnoMQVWIC62ipFeRy2_Ah_WEUushASM,2205
 openrewrite_migrate_python/migrate/xdrlib_migrations.py,sha256=khHPyP1TctExRMl1w_sR9d2fh5_QD04WQDNCqN3wUh4,2140
 openrewrite_migrate_python/migrate/xml_deprecations.py,sha256=mvyEUhVGPQTsjE81OkxBqKQCmis5xqTNg6LcUX1ipp4,7613
-openrewrite_migrate_python-0.19.0.dist-info/METADATA,sha256=kEmqGklwHFGpksEPUrP9U9HkEoc8Y7Q0e9vYlaF8V-A,1450
-openrewrite_migrate_python-0.19.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
-openrewrite_migrate_python-0.19.0.dist-info/entry_points.txt,sha256=SuygzlMJiKIW19FYJVxx0hhRyzW6HTDCweY7584XpXw,138
-openrewrite_migrate_python-0.19.0.dist-info/top_level.txt,sha256=y8dKeC9kb5GUzFraB-OhJGxjPemM3GaPdrAygz2RP0U,59
-openrewrite_migrate_python-0.19.0.dist-info/RECORD,,
+openrewrite_migrate_python-0.20.0.dist-info/METADATA,sha256=DAE-EZVWsrzQUdG46PKrWloODLgLzRMjsHoVt7L-Nzk,1450
+openrewrite_migrate_python-0.20.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+openrewrite_migrate_python-0.20.0.dist-info/entry_points.txt,sha256=SuygzlMJiKIW19FYJVxx0hhRyzW6HTDCweY7584XpXw,138
+openrewrite_migrate_python-0.20.0.dist-info/top_level.txt,sha256=y8dKeC9kb5GUzFraB-OhJGxjPemM3GaPdrAygz2RP0U,59
+openrewrite_migrate_python-0.20.0.dist-info/RECORD,,