openrewrite-migrate-python 0.18.0__tar.gz → 0.20.0__tar.gz

{openrewrite_migrate_python-0.18.0 → openrewrite_migrate_python-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.18.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.18.0 → openrewrite_migrate_python-0.20.0}/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.18.0"  # Updated dynamically during release
+version = "0.20.0"  # Updated dynamically during release
 authors = [{ name = "Moderne Inc.", email = "support@moderne.io" }]
 license = { text = "Moderne Proprietary" }
 readme = "README.md"
@@ -28,7 +28,7 @@ dependencies = []
 
 [project.optional-dependencies]
 dev = [
-    "openrewrite>=8.94.0",
+    "openrewrite>=8.96.3",
     # Needed so type-attribution tests can resolve `pydantic` types.
     "pydantic>=2.11",
     "pytest>=8.0.0",

{openrewrite_migrate_python-0.18.0 → openrewrite_migrate_python-0.20.0}/src/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_migrate_python-0.18.0 → openrewrite_migrate_python-0.20.0}/src/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_migrate_python-0.20.0/src/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_migrate_python-0.18.0 → openrewrite_migrate_python-0.20.0}/src/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_migrate_python-0.18.0 → openrewrite_migrate_python-0.20.0}/src/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-0.18.0 → openrewrite_migrate_python-0.20.0}/src/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())