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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.15.0.dev20260922170519
+Version: 0.15.2
 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.92.3; extra == "dev"
+Requires-Dist: openrewrite>=8.92.18; 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.15.0.dev20260922170519 → openrewrite_migrate_python-0.15.2}/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.2"  # 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.92.3",
+    "openrewrite>=8.92.18",
     # Needed so type-attribution tests can resolve `pydantic` types.
     "pydantic>=2.11",
     "pytest>=8.0.0",

{openrewrite_migrate_python-0.15.0.dev20260922170519 → openrewrite_migrate_python-0.15.2}/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.0.dev20260922170519 → openrewrite_migrate_python-0.15.2}/src/openrewrite_code_quality_python/codequality/_reindent.py

@@ -4,12 +4,15 @@ Python indentation lives in the ``Space`` before each token, so moving a block
 to a shallower nesting level means rewriting every line it spans.
 """
 
-from typing import Optional, TypeVar
+from typing import Optional, TypeVar, cast
 
+from rewrite.java.markers import TrailingComma
 from rewrite.java.support_types import Space
+from rewrite.java.tree import J
+from rewrite.markers import Marker
 from rewrite.python.visitor import PythonVisitor
 
-T = TypeVar("T")
+T = TypeVar("T", bound=J)
 
 
 def inherited_prefix(dropped: Space, body: Space) -> Space:
@@ -65,6 +68,20 @@ class _Reindent(PythonVisitor[None]):
             return space
         return Space(_comments=comments, _whitespace=whitespace)
 
+    def visit_marker(self, marker: Marker, p: None) -> Marker:
+        # The line break before the bracket closing a trailing-comma list
+        # lives on the comma.
+        if isinstance(marker, TrailingComma):
+            suffix = self.visit_space(marker.suffix, p)
+            if suffix is not marker.suffix:
+                return marker.replace(_suffix=suffix)
+        return marker
+
+
+def reindent_space(space: Space, old_base: str, new_base: str) -> Space:
+    """:func:`reindent` for trivia that has no tree to travel with."""
+    return _Reindent(old_base, new_base).visit_space(space, None)
+
 
 def reindent(tree: T, old_base: str, new_base: str) -> T:
     """Re-base every line in *tree* that is indented at least to *old_base*.
@@ -74,4 +91,4 @@ def reindent(tree: T, old_base: str, new_base: str) -> T:
     """
     if old_base == new_base:
         return tree
-    return _Reindent(old_base, new_base).visit(tree, None)
+    return cast(T, _Reindent(old_base, new_base).visit(tree, None))

openrewrite_migrate_python-0.15.2/src/openrewrite_code_quality_python/codequality/_semantically_equal.py

@@ -0,0 +1,38 @@
+"""Semantic equality of LST nodes, for recipes that keep one of two equal subtrees."""
+
+from typing import List, Optional
+
+from rewrite.java.support_types import J, Space
+from rewrite.python.template.comparator import PythonComparatorVisitor
+from rewrite.python.visitor import PythonVisitor
+from rewrite.visitor import Cursor
+
+
+class _CommentTexts(PythonVisitor[List[str]]):
+    def visit_space(self, space: Optional[Space], p: List[str]) -> Space:
+        if space is not None:
+            p.extend(comment.text for comment in space.comments)
+        return super().visit_space(space, p)
+
+
+def _comment_texts(tree: J) -> List[str]:
+    texts: List[str] = []
+    _CommentTexts().visit(tree, texts)
+    return texts
+
+
+class SemanticallyEqual:
+    """Compare two LST nodes for structural equality."""
+
+    @staticmethod
+    def are_equal(a: Optional[J], b: Optional[J]) -> bool:
+        """Whether *a* and *b* are the same code carrying the same comments.
+
+        Whitespace is ignored. Comments must match, so a recipe dropping either copy loses none.
+        """
+        if a is None or b is None:
+            return a is b
+        return (
+            PythonComparatorVisitor().compare(a, b, Cursor(None, Cursor.ROOT_VALUE))
+            and _comment_texts(a) == _comment_texts(b)
+        )

openrewrite_migrate_python-0.15.2/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.15.0.dev20260922170519 → openrewrite_migrate_python-0.15.2}/src/openrewrite_code_quality_python/codequality/_trivia.py

@@ -12,7 +12,7 @@ from typing import Optional, Tuple
 
 from rewrite import Cursor
 from rewrite.java.support_types import Space
-from rewrite.java.tree import Block, ClassDeclaration, If, MethodDeclaration
+from rewrite.java.tree import Block, ClassDeclaration, If, J, MethodDeclaration
 from rewrite.python.tree import CompilationUnit
 
 
@@ -81,9 +81,11 @@ def space_after_block(cursor: Cursor) -> Optional[Space]:
     know how to look past.
     """
     child = cursor.value
+    if not isinstance(child, J):
+        return None
     for parent in islice(cursor.get_path(), 1, None):
         if isinstance(parent, (Block, CompilationUnit)):
-            statements = parent._statements
+            statements = parent.padding.statements
             index = next(
                 (i for i, s in enumerate(statements) if s.element.id == child.id),
                 None,
@@ -125,7 +127,8 @@ def splice_out(
             continue
         if pending is not None:
             head, line = pending
-            _, tail = split_line(padded.element.prefix)
+            prefix = padded.element.prefix
+            _, tail = split_line(prefix) or (Space.EMPTY, prefix)
             padded = padded.replace(
                 _element=padded.element.replace(
                     _prefix=concat(

{openrewrite_migrate_python-0.15.0.dev20260922170519 → openrewrite_migrate_python-0.15.2}/src/openrewrite_code_quality_python/codequality/all_branches_identical.py

@@ -15,7 +15,9 @@ from rewrite import ExecutionContext, Recipe, TreeVisitor
 from rewrite.category import CategoryDescriptor
 from rewrite.decorators import categorize
 from rewrite.marketplace import Python
+from rewrite.python.tree import CompilationUnit
 from rewrite.python.visitor import PythonVisitor
+from rewrite.java.tree import J
 from rewrite.java.tree import (
     Block,
     If,
@@ -27,6 +29,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 +71,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 +104,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 +131,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
@@ -130,19 +146,23 @@ class AllBranchesIdentical(Recipe):
     def editor(self) -> TreeVisitor[Any, ExecutionContext]:
         class Visitor(PythonVisitor[ExecutionContext]):
             def visit_compilation_unit(self, cu, p):
-                cu = super().visit_compilation_unit(cu, p)
-                new_stmts = _replace_identical_ifs_padded(cu._statements)
+                visited = super().visit_compilation_unit(cu, p)
+                if not isinstance(visited, CompilationUnit):
+                    return visited
+                cu = visited
+                new_stmts = _replace_identical_ifs_padded(cu.padding.statements)
                 if new_stmts is not None:
                     return cu.replace(_statements=new_stmts)
                 return cu
 
             def visit_block(
                 self, block: Block, p: ExecutionContext
-            ) -> Optional[Block]:
-                block = super().visit_block(block, p)
-                if not isinstance(block, Block):
-                    return block
-                new_stmts = _replace_identical_ifs_padded(block._statements)
+            ) -> J:
+                visited = super().visit_block(block, p)
+                if not isinstance(visited, Block):
+                    return visited
+                block = visited
+                new_stmts = _replace_identical_ifs_padded(block.padding.statements)
                 if new_stmts is not None:
                     return block.replace(_statements=new_stmts)
                 return block
@@ -163,7 +183,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)
@@ -172,12 +192,12 @@ def _replace_identical_ifs_padded(padded_stmts) -> Optional[list]:
             continue
 
         body = s.then_part
-        if not isinstance(body, Block) or not body._statements:
+        if not isinstance(body, Block) or not body.padding.statements:
             result.append(rp)
             continue
 
         if_indent = line_indent(s.prefix)
-        body_indent = line_indent(body._statements[0].element.prefix)
+        body_indent = line_indent(body.padding.statements[0].element.prefix)
         if (
             if_indent is None
             or body_indent is None
@@ -187,7 +207,7 @@ def _replace_identical_ifs_padded(padded_stmts) -> Optional[list]:
             continue
 
         body = reindent(body, body_indent, if_indent)
-        first = body._statements[0]
+        first = body.padding.statements[0]
         # Each lifted statement keeps its own padding, which is where a `;`
         # separating it from the next one is recorded.
         result.append(
@@ -197,7 +217,7 @@ def _replace_identical_ifs_padded(padded_stmts) -> Optional[list]:
                 )
             )
         )
-        result.extend(body._statements[1:])
+        result.extend(body.padding.statements[1:])
         changed = True
 
     if not changed:

{openrewrite_migrate_python-0.15.0.dev20260922170519 → openrewrite_migrate_python-0.15.2}/src/openrewrite_code_quality_python/codequality/boolean_checks_not_inverted.py

@@ -8,18 +8,23 @@ when written as ``a != b``, and ``not (not x)`` is just ``x``.
 See: https://rules.sonarsource.com/python/RSPEC-S1940/
 """
 
-from typing import Any, List, Optional
+from typing import Any, List
 
-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.tree import J
+from rewrite.java.support_types import JavaType, JLeftPadded
 from rewrite.java.tree import (
+    Assert,
     Binary as JBinary,
+    ControlParentheses,
     Expression,
     Parentheses,
+    Ternary,
     Unary,
 )
 
@@ -37,6 +42,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 +129,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
@@ -86,11 +147,11 @@ class BooleanChecksNotInverted(Recipe):
         class Visitor(PythonVisitor[ExecutionContext]):
             def visit_unary(
                 self, unary: Unary, p: ExecutionContext
-            ) -> Optional[Expression]:
-                unary = super().visit_unary(unary, p)
-
-                if not isinstance(unary, Unary):
-                    return unary
+            ) -> J:
+                visited = super().visit_unary(unary, p)
+                if not isinstance(visited, Unary):
+                    return visited
+                unary = visited
 
                 if unary.operator != Unary.Type.Not:
                     return unary
@@ -103,11 +164,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.15.2/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(),
+        ]