openrewrite-migrate-python 0.14.0.dev20260902131752__tar.gz → 0.14.0.dev20260902134304__tar.gz

{openrewrite_migrate_python-0.14.0.dev20260902131752 → openrewrite_migrate_python-0.14.0.dev20260902134304}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.14.0.dev20260902131752
+Version: 0.14.0.dev20260902134304
 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.dev20260902131752 → openrewrite_migrate_python-0.14.0.dev20260902134304}/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.dev20260902131752"  # Updated dynamically during release
+version = "0.14.0.dev20260902134304"  # 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.dev20260902134304/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.14.0.dev20260902131752 → openrewrite_migrate_python-0.14.0.dev20260902134304}/src/openrewrite_code_quality_python/codequality/remove_self_assignment.py

@@ -16,18 +16,23 @@ from rewrite import Cursor, ExecutionContext, Recipe, TreeVisitor
 from rewrite.category import CategoryDescriptor
 from rewrite.decorators import categorize
 from rewrite.marketplace import Python
+from rewrite.java.support_types import Space
 from rewrite.python.tree import CompilationUnit
 from rewrite.python.visitor import PythonVisitor
-from rewrite.java.support_types import Space
 from rewrite.java.tree import (
     Assignment,
     Block,
     ClassDeclaration,
     Identifier,
-    If,
     MethodDeclaration,
     Statement,
 )
+from openrewrite_code_quality_python.codequality._trivia import (
+    opens_with_trailing_comment,
+    space_after_block,
+    split_line,
+    splice_out,
+)
 
 _CodeQuality = [
     *Python,
@@ -69,95 +74,7 @@ def _in_function_scope(cursor: Cursor) -> bool:
     return False
 
 
-def _space_after_block(cursor: Cursor) -> Optional[Space]:
-    """The trivia the printer emits after the block at ``cursor``.
-
-    A statement's trailing comment is stored on whatever follows it, so a
-    block's last statement keeps its 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 _ends_line_with_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 _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 _removable(padded_statements: list, i: int, space_after_block: Optional[Space]) -> bool:
+def _removable(padded_statements: list, i: int, after_block: Optional[Space]) -> bool:
     """Return True when statement ``i`` can be dropped without disturbing its neighbours.
 
     The removal is expressed by splicing line-level trivia, so the statement
@@ -168,49 +85,29 @@ def _removable(padded_statements: list, i: int, space_after_block: Optional[Spac
     """
     if not _is_local_self_assignment(padded_statements[i].element):
         return False
-    if _split_line(padded_statements[i].element.prefix) is None:
+    if split_line(padded_statements[i].element.prefix) is None:
         return False
     if i + 1 < len(padded_statements):
-        return _split_line(padded_statements[i + 1].element.prefix) is not None
-    return space_after_block is not None and not _ends_line_with_comment(space_after_block)
+        return split_line(padded_statements[i + 1].element.prefix) is not None
+    return after_block is not None and not opens_with_trailing_comment(after_block)
 
 
 def _remove_self_assignments(
-    padded_statements: list, end: Space, space_after_block: Optional[Space]
+    padded_statements: list, end: Space, after_block: Optional[Space]
 ) -> Optional[Tuple[list, Space]]:
     """Return the block's statements and end trivia with self-assignments removed, or None if unchanged.
 
-    Each removed statement's leading trivia is kept up to its own line (it
-    holds the preceding statement's trailing comment) and its successor's is
-    dropped up to the same point (it holds the removed statement's own).
     Emptying a block would leave its header without a body, so the last
     surviving statement stays.
     """
     to_remove = {
         i
         for i in range(len(padded_statements))
-        if _removable(padded_statements, i, space_after_block)
+        if _removable(padded_statements, i, after_block)
     }
     if not to_remove or len(to_remove) == len(padded_statements):
         return None
-
-    result = []
-    pending_head: Optional[Space] = None
-    for i, padded in enumerate(padded_statements):
-        if i in to_remove:
-            if pending_head is None:
-                pending_head, _ = _split_line(padded.element.prefix)
-            continue
-        if pending_head is not None:
-            _, tail = _split_line(padded.element.prefix)
-            padded = padded.replace(
-                _element=padded.element.replace(
-                    _prefix=_concat(pending_head, tail)
-                )
-            )
-            pending_head = None
-        result.append(padded)
-    return result, end if pending_head is None else _concat(pending_head, end)
+    return splice_out(padded_statements, end, to_remove)
 
 
 @categorize(_CodeQuality)
@@ -266,7 +163,7 @@ class RemoveSelfAssignment(Recipe):
                 if not isinstance(block, Block) or not _in_function_scope(self.cursor):
                     return block
                 removed = _remove_self_assignments(
-                    block._statements, block.end, _space_after_block(self.cursor)
+                    block._statements, block.end, space_after_block(self.cursor)
                 )
                 if removed is not None:
                     return block.replace(_statements=removed[0], _end=removed[1])

{openrewrite_migrate_python-0.14.0.dev20260902131752 → openrewrite_migrate_python-0.14.0.dev20260902134304}/src/openrewrite_code_quality_python/codequality/remove_unconditional_value_overwrite.py

@@ -9,25 +9,26 @@ eliminates noise and prevents confusion about the author's intent.
 See: https://rules.sonarsource.com/python/RSPEC-S4143/
 """
 
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Tuple
 
 from rewrite import ExecutionContext, Recipe, TreeVisitor
 from rewrite.category import CategoryDescriptor
 from rewrite.decorators import categorize
 from rewrite.marketplace import Python
 from rewrite.python.visitor import PythonVisitor
-from rewrite.python.tree import ExpressionStatement
-from rewrite.java.support_types import Space
+from rewrite.python.tree import Await, CompilationUnit, ExpressionStatement, YieldFrom
+from rewrite.java.support_types import MethodCall, Space
 from rewrite.java.tree import (
     ArrayAccess,
     Assignment,
     Block,
     Expression,
     FieldAccess,
-    Identifier,
     Statement,
+    Yield,
 )
 from openrewrite_code_quality_python.codequality._semantically_equal import SemanticallyEqual
+from openrewrite_code_quality_python.codequality._trivia import splice_out, split_line
 
 _CodeQuality = [
     *Python,
@@ -81,6 +82,56 @@ def _same_attribute_target(a: Assignment, b: Assignment) -> bool:
     )
 
 
+class _Find(PythonVisitor[None]):
+    """Records whether any subtree of the visited node satisfies ``predicate``."""
+
+    def __init__(self, predicate):
+        super().__init__()
+        self._predicate = predicate
+        self.found = False
+
+    def visit(self, tree, p, parent=None):
+        if tree is not None and self._predicate(tree):
+            self.found = True
+        return super().visit(tree, p, parent)
+
+
+def _contains(node, predicate) -> bool:
+    search = _Find(predicate)
+    search.visit(node, None)
+    return search.found
+
+
+# A walrus binds a name; the rest reach code this recipe cannot see.
+_EFFECTFUL = (Assignment, Await, MethodCall, Yield, YieldFrom)
+
+
+def _has_side_effects(expression: Expression) -> bool:
+    """Return True when evaluating ``expression`` can do more than produce a value."""
+    return _contains(expression, lambda node: isinstance(node, _EFFECTFUL))
+
+
+def _receiver(assign: Assignment) -> Expression:
+    """The object the assignment writes through."""
+    variable = assign.variable
+    return variable.indexed if isinstance(variable, ArrayAccess) else variable.target
+
+
+def _observes_earlier_write(a: Assignment, b: Assignment) -> bool:
+    """Return True when evaluating ``b``'s value can see what ``a`` wrote.
+
+    Reading the target back (``d[k] = d[k].strip()``) is the direct case, but
+    the write is equally visible through the object that holds it: whether
+    ``d[k] = 0`` added a key or replaced one decides ``len(d)``, and an
+    attribute read can run a property computed from the one just written.
+    """
+    receiver = _receiver(a)
+    return _contains(
+        b.assignment,
+        lambda node: isinstance(node, Expression) and SemanticallyEqual.are_equal(node, receiver),
+    )
+
+
 def _is_duplicate_write(a: Assignment, b: Assignment) -> bool:
     """Return True if a and b write to the same target."""
     if _is_subscript_assign(a) and _is_subscript_assign(b):
@@ -90,6 +141,21 @@ def _is_duplicate_write(a: Assignment, b: Assignment) -> bool:
     return False
 
 
+def _is_dead_write(a: Assignment, b: Assignment) -> bool:
+    """Return True when ``b`` leaves nothing ``a`` did observable.
+
+    Targets are matched as written, so one that names a different location
+    each time it is evaluated (``d[next(it)]``) is two targets, not one.  A
+    value that does more than produce a value keeps its statement alive even
+    once the store it makes is dead.
+    """
+    if not _is_duplicate_write(a, b):
+        return False
+    if _has_side_effects(a.variable) or _has_side_effects(a.assignment):
+        return False
+    return not _observes_earlier_write(a, b)
+
+
 @categorize(_CodeQuality)
 class RemoveUnconditionalValueOverwrite(Recipe):
     """
@@ -123,7 +189,9 @@ class RemoveUnconditionalValueOverwrite(Recipe):
         return (
             "Remove consecutive assignments that write to the same dict key "
             "or object attribute, since the first value is immediately "
-            "overwritten and never used."
+            "overwritten and never used. A write the second one can still "
+            "observe -- by reading the target back, or through the object "
+            "holding it -- is left alone."
         )
 
     @property
@@ -136,72 +204,55 @@ class RemoveUnconditionalValueOverwrite(Recipe):
 
     def editor(self) -> TreeVisitor[Any, ExecutionContext]:
         class Visitor(PythonVisitor[ExecutionContext]):
-            def visit_compilation_unit(self, cu, p):
+            def visit_compilation_unit(
+                self, cu: CompilationUnit, p: ExecutionContext
+            ) -> CompilationUnit:
                 cu = super().visit_compilation_unit(cu, p)
-                new_stmts = _remove_overwrites_padded(cu._statements)
-                if new_stmts is not None:
-                    return cu.replace(_statements=new_stmts)
+                removed = _remove_overwrites(cu._statements, cu.eof, starts_file=True)
+                if removed is not None:
+                    return cu.replace(_statements=removed[0], _eof=removed[1])
                 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 = _remove_overwrites_padded(block._statements)
-                if new_stmts is not None:
-                    return block.replace(_statements=new_stmts)
+                removed = _remove_overwrites(block._statements, block.end, starts_file=False)
+                if removed is not None:
+                    return block.replace(_statements=removed[0], _end=removed[1])
                 return block
 
         return Visitor()
 
 
-def _remove_overwrites_padded(padded_stmts) -> Optional[list]:
-    """Return a filtered padded list with dead writes removed, or None if unchanged."""
-    if len(padded_stmts) < 2:
-        return None
-
-    stmts = [rp.element for rp in padded_stmts]
-    to_remove: set[int] = set()
-    for i in range(len(stmts) - 1):
-        if i in to_remove:
-            continue
-        a_assign = _get_assignment(stmts[i])
-        if a_assign is None:
-            continue
-        if not (_is_subscript_assign(a_assign) or _is_attribute_assign(a_assign)):
-            continue
+def _removable(padded_statements: list, i: int, starts_file: bool) -> bool:
+    """Return True when the write at ``i`` is dead and can be dropped by splicing lines.
 
-        b_assign = _get_assignment(stmts[i + 1])
-        if b_assign is None:
-            continue
+    Both the write and its overwrite have to start a line of their own,
+    which a `;`-joined pair does not; a file's first statement starts one
+    with no line break to show for it.
+    """
+    if i + 1 >= len(padded_statements):
+        return False
+    a = _get_assignment(padded_statements[i].element)
+    b = _get_assignment(padded_statements[i + 1].element)
+    if a is None or b is None or not _is_dead_write(a, b):
+        return False
+    if not (starts_file and i == 0) and split_line(padded_statements[i].element.prefix) is None:
+        return False
+    return split_line(padded_statements[i + 1].element.prefix) is not None
 
-        if _is_duplicate_write(a_assign, b_assign):
-            to_remove.add(i)
 
+def _remove_overwrites(
+    padded_statements: list, end: Space, starts_file: bool
+) -> Optional[Tuple[list, Space]]:
+    """Return the statements and end trivia with dead writes removed, or None if unchanged."""
+    to_remove = {
+        i for i in range(len(padded_statements))
+        if _removable(padded_statements, i, starts_file)
+    }
     if not to_remove:
         return None
-
-    result = [
-        rp for idx, rp in enumerate(padded_stmts)
-        if idx not in to_remove
-    ]
-
-    # If we removed the first statement(s), strip the leading newline
-    # from the new first statement's prefix to avoid a blank line.
-    if result and 0 in to_remove:
-        first_rp = result[0]
-        first = first_rp.element
-        ws = first.prefix.whitespace
-        if ws.startswith("\n"):
-            ws = ws[1:]
-            new_first = first.replace(_prefix=Space(
-                _comments=first.prefix.comments,
-                _whitespace=ws,
-            ))
-            result[0] = first_rp.replace(_element=new_first)
-
-    return result
+    return splice_out(padded_statements, end, to_remove)

{openrewrite_migrate_python-0.14.0.dev20260902131752 → openrewrite_migrate_python-0.14.0.dev20260902134304}/src/openrewrite_migrate_python.egg-info/PKG-INFO

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

@@ -3,6 +3,7 @@ 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/_trivia.py
 src/openrewrite_code_quality_python/codequality/all_branches_identical.py
 src/openrewrite_code_quality_python/codequality/boolean_checks_not_inverted.py
 src/openrewrite_code_quality_python/codequality/collapsible_if_statements.py