openrewrite-migrate-python 0.14.0.dev20260902064123__tar.gz → 0.14.0.dev20260902102558__tar.gz

{openrewrite_migrate_python-0.14.0.dev20260902064123 → openrewrite_migrate_python-0.14.0.dev20260902102558}/PKG-INFO

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

openrewrite_migrate_python-0.14.0.dev20260902102558/src/openrewrite_code_quality_python/codequality/_reindent.py

@@ -0,0 +1,93 @@
+"""Shared indentation helpers for recipes that lift a block out of its parent.
+
+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 rewrite.java.support_types import Space
+from rewrite.java.tree import Statement
+from rewrite.python.tree import ExpressionStatement, StatementExpression
+from rewrite.python.visitor import PythonVisitor
+
+T = TypeVar("T")
+
+
+def inherited_prefix(dropped: Space, body: Space) -> Space:
+    """Prefix for the statement that takes the place of a dropped enclosing node.
+
+    It starts where the dropped node started, and the comments the dropped node
+    carried stay ahead of the body's own. Those comments' suffixes already
+    indent to the level the body now occupies.
+    """
+    return Space(
+        _comments=[*dropped.comments, *body.comments],
+        _whitespace=dropped.whitespace,
+    )
+
+
+def with_prefix(stmt: Statement, prefix: Space) -> Statement:
+    """Set the prefix of *stmt*, threading through the ``Py`` wrappers whose
+    own prefix is a read-only view of the node they hold.
+
+    Drop once openrewrite/rewrite#8742 is the version floor: it gives those
+    wrappers a write path, so `stmt.replace(_prefix=...)` suffices alone.
+    """
+    if isinstance(stmt, ExpressionStatement):
+        return stmt.replace(_expression=with_prefix(stmt.expression, prefix))
+    if isinstance(stmt, StatementExpression):
+        return stmt.replace(_statement=with_prefix(stmt.statement, prefix))
+    return stmt.replace(_prefix=prefix)
+
+
+def line_indent(space: Space) -> Optional[str]:
+    """Indentation of the line the token following *space* starts on, or
+    ``None`` when that token shares a line with what precedes it.
+
+    A trailing comment puts the newline in the comment's suffix rather than in
+    ``Space.whitespace``; empty whitespace is a file's first token, at column 0.
+    """
+    text = space.comments[-1].suffix if space.comments else space.whitespace
+    if "\n" in text:
+        return text.rsplit("\n", 1)[-1]
+    return text if text == "" else None
+
+
+def _rebase(text: str, old_base: str, new_base: str) -> str:
+    head, sep, indent = text.rpartition("\n")
+    if not sep or not indent.startswith(old_base):
+        return text
+    return head + sep + new_base + indent[len(old_base):]
+
+
+class _Reindent(PythonVisitor[None]):
+    def __init__(self, old_base: str, new_base: str):
+        super().__init__()
+        self._old_base = old_base
+        self._new_base = new_base
+
+    def visit_space(self, space: Optional[Space], p: None) -> Space:
+        if space is None:
+            return Space.EMPTY
+        whitespace = _rebase(space.whitespace, self._old_base, self._new_base)
+        comments = [
+            c.replace(suffix=_rebase(c.suffix, self._old_base, self._new_base))
+            for c in space.comments
+        ]
+        if whitespace == space.whitespace and all(
+            c.suffix == o.suffix for c, o in zip(comments, space.comments)
+        ):
+            return space
+        return Space(_comments=comments, _whitespace=whitespace)
+
+
+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*.
+
+    Lines indented less deeply are continuation lines whose alignment is
+    independent of the block's nesting, so they are left alone.
+    """
+    if old_base == new_base:
+        return tree
+    return _Reindent(old_base, new_base).visit(tree, None)

{openrewrite_migrate_python-0.14.0.dev20260902064123 → openrewrite_migrate_python-0.14.0.dev20260902102558}/src/openrewrite_code_quality_python/codequality/all_branches_identical.py

@@ -16,12 +16,17 @@ from rewrite.category import CategoryDescriptor
 from rewrite.decorators import categorize
 from rewrite.marketplace import Python
 from rewrite.python.visitor import PythonVisitor
-from rewrite.java.support_types import Space
 from rewrite.java.tree import (
     Block,
     If,
     Statement,
 )
+from openrewrite_code_quality_python.codequality._reindent import (
+    inherited_prefix,
+    line_indent,
+    reindent,
+    with_prefix,
+)
 from openrewrite_code_quality_python.codequality._semantically_equal import SemanticallyEqual
 
 _CodeQuality = [
@@ -152,9 +157,6 @@ def _replace_identical_ifs_padded(padded_stmts) -> Optional[list]:
     Works on a list of JRightPadded[Statement] and returns a new padded list,
     or None if nothing changed.
     """
-    from rewrite.java.support_types import JRightPadded
-    from rewrite.markers import Markers
-
     result = []
     changed = False
     for rp in padded_stmts:
@@ -170,36 +172,34 @@ def _replace_identical_ifs_padded(padded_stmts) -> Optional[list]:
             result.append(rp)
             continue
 
-        # Extract the body statements from the then_part Block.
         body = s.then_part
-        if isinstance(body, Block) and body._statements:
-            first = True
-            for body_rp in body._statements:
-                bs = body_rp.element
-                if first:
-                    # First body statement gets the if statement's prefix
-                    new_elem = bs.replace(_prefix=s.prefix)
-                    result.append(rp.replace(_element=new_elem))
-                    first = False
-                else:
-                    # Subsequent body statements keep their whitespace
-                    # but with one indent level removed
-                    ws = bs.prefix.whitespace
-                    if_ws = s.prefix.whitespace
-                    base = if_ws.split("\n")[-1] if "\n" in if_ws else if_ws
-                    body_indent = ws.split("\n")[-1] if "\n" in ws else ws
-                    if len(body_indent) > len(base):
-                        new_ws = ws.replace(body_indent, base, 1)
-                    else:
-                        new_ws = ws
-                    new_elem = bs.replace(_prefix=Space(
-                        _comments=bs.prefix.comments,
-                        _whitespace=new_ws,
-                    ))
-                    result.append(body_rp.replace(_element=new_elem))
-            changed = True
-        else:
+        if not isinstance(body, Block) or not body._statements:
             result.append(rp)
+            continue
+
+        if_indent = line_indent(s.prefix)
+        body_indent = line_indent(body._statements[0].element.prefix)
+        if (
+            if_indent is None
+            or body_indent is None
+            or not body_indent.startswith(if_indent)
+        ):
+            result.append(rp)
+            continue
+
+        body = reindent(body, body_indent, if_indent)
+        first = body._statements[0]
+        # Each lifted statement keeps its own padding, which is where a `;`
+        # separating it from the next one is recorded.
+        result.append(
+            first.replace(
+                _element=with_prefix(
+                    first.element, inherited_prefix(s.prefix, first.element.prefix)
+                )
+            )
+        )
+        result.extend(body._statements[1:])
+        changed = True
 
     if not changed:
         return None

{openrewrite_migrate_python-0.14.0.dev20260902064123 → openrewrite_migrate_python-0.14.0.dev20260902102558}/src/openrewrite_code_quality_python/codequality/collapsible_if_statements.py

@@ -16,43 +16,62 @@ from rewrite.category import CategoryDescriptor
 from rewrite.decorators import categorize
 from rewrite.marketplace import Python
 from rewrite.markers import Markers
+from rewrite.python.tree import StatementExpression
 from rewrite.python.visitor import PythonVisitor
 from rewrite.java.support_types import JLeftPadded, JRightPadded, Space
 from rewrite.java.tree import (
+    Assignment,
     Binary as JBinary,
     Block,
     ControlParentheses,
     Expression,
     If,
+    Lambda,
     Parentheses,
+    Ternary,
 )
 from rewrite.utils import random_id
 
+from openrewrite_code_quality_python.codequality._reindent import (
+    inherited_prefix,
+    line_indent,
+    reindent,
+    with_prefix,
+)
+
 _CodeQuality = [
     *Python,
     CategoryDescriptor(display_name="Code quality"),
 ]
 
 
-def _contains_or(expr: Expression) -> bool:
-    """Return True if the top-level expression is an ``or`` binary."""
-    return isinstance(expr, JBinary) and expr.operator == JBinary.Type.Or
+def _binds_looser_than_and(expr: Expression) -> bool:
+    """Return True for the operand forms that ``and`` would capture.
 
-
-def _dedent_block(block: Block, indent: str) -> Block:
-    """Remove one level of *indent* from every statement in *block*."""
-    if not indent:
-        return block
-    new_stmts = []
-    for rp in block._statements:
-        s = rp.element
-        ws = s.prefix.whitespace
-        if indent in ws:
-            ws = ws.replace(indent, "", 1)
-            s = s.replace(_prefix=Space(_comments=s.prefix.comments, _whitespace=ws))
-            rp = rp.replace(_element=s)
-        new_stmts.append(rp)
-    return block.replace(_statements=new_stmts)
+    Everything below ``and`` in Python's precedence table: ``or``, the
+    conditional expression, ``lambda``, ``:=`` (a ``J.Assignment`` here) and
+    ``yield`` (a ``Py.StatementExpression``).
+    """
+    if isinstance(expr, JBinary):
+        return expr.operator == JBinary.Type.Or
+    return isinstance(expr, (Ternary, Lambda, Assignment, StatementExpression))
+
+
+def _operand(expr: Expression, prefix: Space) -> Expression:
+    """Prepare *expr* as an operand of the merged ``and``, parenthesizing it
+    when its own operator would otherwise be captured."""
+    if _binds_looser_than_and(expr):
+        return Parentheses(
+            _id=random_id(),
+            _prefix=prefix,
+            _markers=Markers.EMPTY,
+            _tree=JRightPadded(
+                _element=expr.replace(_prefix=Space.EMPTY),
+                _after=Space.EMPTY,
+                _markers=Markers.EMPTY,
+            ),
+        )
+    return expr.replace(_prefix=prefix)
 
 
 @categorize(_CodeQuality)
@@ -129,36 +148,34 @@ class CollapsibleIfStatements(Recipe):
                 if inner.else_part is not None:
                     return if_
 
-                outer_cond = if_.if_condition.tree
-                inner_cond = inner.if_condition.tree
+                inner_body = inner.then_part
+                if not isinstance(inner_body, Block) or not inner_body.statements:
+                    return if_
 
-                # Wrap inner condition in parens if it contains `or`
-                # to preserve precedence with the new `and`
-                if _contains_or(inner_cond):
-                    inner_cond = Parentheses(
-                        _id=random_id(),
-                        _prefix=Space.SINGLE_SPACE,
-                        _markers=Markers.EMPTY,
-                        _tree=JRightPadded(
-                            _element=inner_cond.replace(_prefix=Space.EMPTY),
-                            _after=Space.EMPTY,
-                            _markers=Markers.EMPTY,
-                        ),
-                    )
-                else:
-                    inner_cond = inner_cond.replace(_prefix=Space.SINGLE_SPACE)
+                # The body rises to where the inner `if` header sat, which is
+                # always deeper than the surviving header whatever the file's
+                # indent unit -- and is a line start even when the outer `if`
+                # is an `elif`, whose own prefix holds no newline.
+                header_indent = line_indent(inner.prefix)
+                body_indent = line_indent(inner_body.statements[0].prefix)
+                if (
+                    header_indent is None
+                    or body_indent is None
+                    or not body_indent.startswith(header_indent)
+                ):
+                    return if_
 
                 combined = JBinary(
                     _id=random_id(),
-                    _prefix=outer_cond.prefix,
+                    _prefix=if_.if_condition.tree.prefix,
                     _markers=Markers.EMPTY,
-                    _left=outer_cond.replace(_prefix=Space.EMPTY),
+                    _left=_operand(if_.if_condition.tree, Space.EMPTY),
                     _operator=JLeftPadded(
                         _before=Space.SINGLE_SPACE,
                         _element=JBinary.Type.And,
                         _markers=Markers.EMPTY,
                     ),
-                    _right=inner_cond,
+                    _right=_operand(inner.if_condition.tree, Space.SINGLE_SPACE),
                     _type=None,
                 )
 
@@ -173,14 +190,22 @@ class CollapsibleIfStatements(Recipe):
                     ),
                 )
 
-                # Dedent the inner body by one level since it was
-                # nested inside the inner if that we're removing.
-                inner_body = inner.then_part
-                if isinstance(inner_body, Block):
-                    # The inner if's prefix tells us the indent unit
-                    ws = inner.prefix.whitespace
-                    indent = ws.split("\n")[-1] if "\n" in ws else ws
-                    inner_body = _dedent_block(inner_body, indent)
+                # One level per visit: a chain of three or more `if`s merges a
+                # level at a time, and each pass rebases the comments the
+                # previous one left at the level it dropped.
+                inner_body = reindent(inner_body, body_indent, header_indent)
+                first = inner_body._statements[0]
+                inner_body = inner_body.replace(
+                    _statements=[
+                        first.replace(
+                            _element=with_prefix(
+                                first.element,
+                                inherited_prefix(inner.prefix, first.element.prefix),
+                            )
+                        ),
+                        *inner_body._statements[1:],
+                    ]
+                )
 
                 return if_.replace(
                     _if_condition=new_condition,

{openrewrite_migrate_python-0.14.0.dev20260902064123 → openrewrite_migrate_python-0.14.0.dev20260902102558}/src/openrewrite_migrate_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.14.0.dev20260902064123
+Version: 0.14.0.dev20260902102558
 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.14.0.dev20260902064123 → openrewrite_migrate_python-0.14.0.dev20260902102558}/src/openrewrite_migrate_python.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 pyproject.toml
 src/openrewrite_code_quality_python/__init__.py
 src/openrewrite_code_quality_python/codequality/__init__.py
+src/openrewrite_code_quality_python/codequality/_reindent.py
 src/openrewrite_code_quality_python/codequality/_semantically_equal.py
 src/openrewrite_code_quality_python/codequality/all_branches_identical.py
 src/openrewrite_code_quality_python/codequality/boolean_checks_not_inverted.py