openrewrite-migrate-python 0.13.1__tar.gz → 0.13.2__tar.gz

{openrewrite_migrate_python-0.13.1 → openrewrite_migrate_python-0.13.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.13.1
+Version: 0.13.2
 Summary: OpenRewrite recipes for migrating Python codebases to newer Python versions.
 Author-email: "Moderne Inc." <support@moderne.io>
 License: Moderne Proprietary
@@ -21,7 +21,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Provides-Extra: dev
-Requires-Dist: openrewrite>=8.89.1; extra == "dev"
+Requires-Dist: openrewrite>=8.91.5; 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.13.1 → openrewrite_migrate_python-0.13.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.13.1"  # Updated dynamically during release
+version = "0.13.2"  # Updated dynamically during release
 authors = [{ name = "Moderne Inc.", email = "support@moderne.io" }]
 license = { text = "Moderne Proprietary" }
 readme = "README.md"
@@ -30,11 +30,7 @@ dependencies = []
 
 [project.optional-dependencies]
 dev = [
-    # 8.89.1 for `python.scope_utils.LocalBindings`, which tells a local apart from a
-    # reference to an import: the PEP 585 recipes use it directly, and `ChangeImport`
-    # and `RemoveImport` need it to see references inside functions. openrewrite is
-    # host-provided at runtime, so this floor only affects dev/CI.
-    "openrewrite>=8.89.1",
+    "openrewrite>=8.91.5",
     # Needed so type-attribution tests can resolve `pydantic` types.
     "pydantic>=2.11",
     "pytest>=8.0.0",

openrewrite_migrate_python-0.13.2/src/openrewrite_code_quality_python/codequality/_reindent.py

@@ -0,0 +1,77 @@
+"""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.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 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.13.2/src/openrewrite_code_quality_python/codequality/_trivia.py

@@ -0,0 +1,139 @@
+"""
+Line-level trivia splicing for recipes that delete whole statements.
+
+A statement's *trailing* comment is stored on whatever the printer emits
+next -- the following statement's prefix, or, for a block's last statement,
+trivia outside the block.  Deleting a statement therefore moves trivia
+between its neighbours.
+"""
+
+from itertools import islice
+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.python.tree import CompilationUnit
+
+
+def split_line(space: Space) -> Optional[Tuple[Space, Space]]:
+    """Split ``space`` at its first newline, or return None if it has no newline.
+
+    The head is the trivia that still belongs to the preceding line -- most
+    importantly that line's trailing comment.  The tail starts with the
+    newline itself.
+    """
+    newline = space.whitespace.find("\n")
+    if newline != -1:
+        return (
+            Space(_comments=[], _whitespace=space.whitespace[:newline]),
+            Space(_comments=space.comments, _whitespace=space.whitespace[newline:]),
+        )
+    for i, comment in enumerate(space.comments):
+        newline = comment.suffix.find("\n")
+        if newline != -1:
+            return (
+                Space(
+                    _comments=[
+                        *space.comments[:i],
+                        comment.replace(_suffix=comment.suffix[:newline]),
+                    ],
+                    _whitespace=space.whitespace,
+                ),
+                Space(
+                    _comments=space.comments[i + 1:],
+                    _whitespace=comment.suffix[newline:],
+                ),
+            )
+    return None
+
+
+def concat(left: Space, right: Space) -> Space:
+    """Return the trivia that prints as ``left`` followed by ``right``."""
+    if not left.comments:
+        return Space(
+            _comments=right.comments,
+            _whitespace=left.whitespace + right.whitespace,
+        )
+    last = left.comments[-1]
+    return Space(
+        _comments=[
+            *left.comments[:-1],
+            last.replace(_suffix=last.suffix + right.whitespace),
+            *right.comments,
+        ],
+        _whitespace=left.whitespace,
+    )
+
+
+def opens_with_trailing_comment(space: Space) -> bool:
+    """Return True when ``space`` opens with a comment on the line it continues."""
+    split = split_line(space)
+    return bool((split[0] if split else space).comments)
+
+
+def space_after_block(cursor: Cursor) -> Optional[Space]:
+    """The trivia the printer emits after the block at ``cursor``.
+
+    A block's last statement keeps its trailing comment outside the block --
+    on the next statement of an enclosing block, on the `else` of an enclosing
+    `if`, or at end of file.  Returns None for the containers this does not
+    know how to look past.
+    """
+    child = cursor.value
+    for parent in islice(cursor.get_path(), 1, None):
+        if isinstance(parent, (Block, CompilationUnit)):
+            statements = parent._statements
+            index = next(
+                (i for i, s in enumerate(statements) if s.element.id == child.id),
+                None,
+            )
+            if index is None:
+                return None
+            if index + 1 < len(statements):
+                return statements[index + 1].element.prefix
+            if isinstance(parent, CompilationUnit):
+                return parent.eof
+        elif isinstance(parent, If):
+            if parent.else_part is not None and parent.else_part.id != child.id:
+                return parent.else_part.prefix
+        elif not isinstance(parent, (ClassDeclaration, If.Else, MethodDeclaration)):
+            return None
+        child = parent
+    return None
+
+
+def splice_out(
+    padded_statements: list, end: Space, to_remove: set[int]
+) -> Tuple[list, Space]:
+    """Return the statements without those at ``to_remove``, and the new end trivia.
+
+    The survivor takes the removed statement's place on the page: the trivia
+    up to the removed statement's own line, which holds the preceding
+    statement's trailing comment, then that line's break and indent.  Only
+    comments standing on their own line before the survivor come from the
+    survivor; the removed statement's go with it.
+    """
+    result = []
+    pending: Optional[Tuple[Space, Space]] = None
+    for i, padded in enumerate(padded_statements):
+        if i in to_remove:
+            if pending is None:
+                prefix = padded.element.prefix
+                # A file's first statement starts a line without a break to show for it.
+                pending = split_line(prefix) or (prefix, Space.EMPTY)
+            continue
+        if pending is not None:
+            head, line = pending
+            _, tail = split_line(padded.element.prefix)
+            padded = padded.replace(
+                _element=padded.element.replace(
+                    _prefix=concat(
+                        head,
+                        Space(_comments=tail.comments, _whitespace=line.whitespace),
+                    )
+                )
+            )
+            pending = None
+        result.append(padded)
+    return result, end if pending is None else concat(pending[0], end)

{openrewrite_migrate_python-0.13.1 → openrewrite_migrate_python-0.13.2}/src/openrewrite_code_quality_python/codequality/all_branches_identical.py

@@ -16,12 +16,16 @@ 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,
+)
 from openrewrite_code_quality_python.codequality._semantically_equal import SemanticallyEqual
 
 _CodeQuality = [
@@ -152,9 +156,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 +171,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=first.element.replace(
+                    _prefix=inherited_prefix(s.prefix, first.element.prefix)
+                )
+            )
+        )
+        result.extend(body._statements[1:])
+        changed = True
 
     if not changed:
         return None

{openrewrite_migrate_python-0.13.1 → openrewrite_migrate_python-0.13.2}/src/openrewrite_code_quality_python/codequality/collapsible_if_statements.py

@@ -16,43 +16,61 @@ 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,
+)
+
 _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 +147,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 +189,21 @@ 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=first.element.replace(
+                                _prefix=inherited_prefix(inner.prefix, first.element.prefix)
+                            )
+                        ),
+                        *inner_body._statements[1:],
+                    ]
+                )
 
                 return if_.replace(
                     _if_condition=new_condition,