openrewrite-migrate-python 0.16.0.dev20261004180356__tar.gz → 0.16.0.dev20261005072603__tar.gz

{openrewrite_migrate_python-0.16.0.dev20261004180356 → openrewrite_migrate_python-0.16.0.dev20261005072603}/PKG-INFO

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

openrewrite_migrate_python-0.16.0.dev20261005072603/src/openrewrite_code_quality_python/codequality/remove_unconditional_value_overwrite.py

@@ -0,0 +1,333 @@
+"""
+Recipe to remove dict entry writes that the next statement overwrites.
+
+See: https://rules.sonarsource.com/python/RSPEC-S4143/
+"""
+
+from itertools import islice
+from typing import Any, List, Optional, Tuple
+
+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.method_matcher import MethodMatcher
+from rewrite.python.visitor import PythonVisitor
+from rewrite.python.tree import (
+    CollectionLiteral,
+    CompilationUnit,
+    ComprehensionExpression,
+    DictLiteral,
+    ExpressionStatement,
+    KeyValue,
+    NamedArgument,
+    TypeHintedExpression,
+    VariableScope,
+)
+from rewrite.java.support_types import Space
+from rewrite.java.tree import (
+    ArrayAccess,
+    Assignment,
+    Block,
+    ClassDeclaration,
+    Empty,
+    Expression,
+    Identifier,
+    J,
+    Lambda,
+    Literal,
+    MethodDeclaration,
+    MethodInvocation,
+    Parentheses,
+    Statement,
+    Try,
+    Unary,
+)
+from openrewrite_code_quality_python.codequality._semantically_equal import SemanticallyEqual
+from openrewrite_code_quality_python.codequality._trivia import splice_out, split_line
+
+_CodeQuality = [
+    *Python,
+    CategoryDescriptor(display_name="Code quality"),
+]
+
+
+def _get_assignment(stmt: Statement) -> Optional[Assignment]:
+    """Extract an Assignment from a statement, if present."""
+    if isinstance(stmt, ExpressionStatement):
+        expr = stmt.expression
+        if isinstance(expr, Assignment):
+            return expr
+    if isinstance(stmt, Assignment):
+        return stmt
+    return None
+
+
+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
+
+
+def _mentions(node, name: str) -> bool:
+    return _contains(node, lambda n: isinstance(n, Identifier) and n.simple_name == name)
+
+
+def _is_number(expression: J) -> bool:
+    return (
+        isinstance(expression, Unary)
+        and expression.operator in (Unary.Type.Negative, Unary.Type.Positive)
+        and isinstance(expression.expression, Literal)
+        and isinstance(expression.expression.value, (int, float, complex))
+    )
+
+
+def _is_hashable_constant(expression: J) -> bool:
+    """A value whose hashing and comparison run no user code and cannot raise."""
+    if isinstance(expression, Parentheses) and isinstance(expression.tree, Expression):
+        return _is_hashable_constant(expression.tree)
+    if isinstance(expression, Literal) or _is_number(expression):
+        return True
+    return (
+        isinstance(expression, CollectionLiteral)
+        and expression.kind == CollectionLiteral.Kind.TUPLE
+        and all(_is_hashable_constant(e) for e in expression.elements if not isinstance(e, Empty))
+    )
+
+
+def _is_constant(expression: J) -> bool:
+    """A value whose evaluation runs no user code and cannot raise."""
+    if isinstance(expression, Parentheses) and isinstance(expression.tree, Expression):
+        return _is_constant(expression.tree)
+    if isinstance(expression, CollectionLiteral):
+        element_ok = _is_hashable_constant if expression.kind == CollectionLiteral.Kind.SET else _is_constant
+        return all(element_ok(e) for e in expression.elements if not isinstance(e, Empty))
+    if isinstance(expression, DictLiteral):
+        return all(
+            isinstance(e, KeyValue) and _is_hashable_constant(e.key) and _is_constant(e.value)
+            for e in expression.elements
+            if not isinstance(e, Empty)
+        )
+    return _is_hashable_constant(expression)
+
+
+def _store(stmt: Statement) -> Optional[Tuple[str, Expression, Expression]]:
+    """The dict name, key and value of a ``d[key] = value`` statement with a constant key."""
+    assign = _get_assignment(stmt)
+    if assign is None or not isinstance(assign.variable, ArrayAccess):
+        return None
+    receiver = assign.variable.indexed
+    key = assign.variable.dimension.index
+    if not isinstance(receiver, Identifier) or not _is_hashable_constant(key):
+        return None
+    return receiver.simple_name, key, assign.assignment
+
+
+_DICT_CONSTRUCTOR = MethodMatcher.create("dict <constructor>(..)")
+
+
+def _builds_dict(value: Expression) -> bool:
+    """True when ``value`` is a new builtin dict holding only constant keys."""
+    if isinstance(value, DictLiteral):
+        return all(
+            isinstance(e, KeyValue) and _is_hashable_constant(e.key)
+            for e in value.elements
+            if not isinstance(e, Empty)
+        )
+    return (
+        isinstance(value, MethodInvocation)
+        and _DICT_CONSTRUCTOR.matches(value)
+        and all(isinstance(a, (NamedArgument, Empty)) for a in value.arguments)
+    )
+
+
+def _binds_fresh_dict(stmt: Statement, name: str) -> bool:
+    assign = _get_assignment(stmt)
+    if assign is None:
+        return False
+    variable = assign.variable
+    if isinstance(variable, TypeHintedExpression):
+        variable = variable.expression
+    return (
+        isinstance(variable, Identifier)
+        and variable.simple_name == name
+        and _builds_dict(assign.assignment)
+    )
+
+
+def _is_fresh_at(statements: List[Statement], i: int, name: str) -> bool:
+    """True when ``name`` holds a dict this block built and has kept to itself up to ``i``.
+
+    Rebinding the dict on every pass through the block keeps it fresh in a
+    loop too.  Only constant-key stores may touch it in between, so every key
+    it holds hashes and compares without running user code.
+    """
+    for stmt in reversed(statements[:i]):
+        if _binds_fresh_dict(stmt, name):
+            return True
+        store = _store(stmt)
+        if store is not None and store[0] == name and not _mentions(store[2], name):
+            continue
+        if _mentions(stmt, name):
+            return False
+    return False
+
+
+_NESTED_SCOPES = (ClassDeclaration, ComprehensionExpression, Lambda, MethodDeclaration)
+
+
+def _shared_beyond_frame(function: MethodDeclaration, name: str) -> bool:
+    """True when ``name`` in ``function`` is a global, or a cell a nested scope can read."""
+    return _contains(
+        function.body,
+        lambda n: (
+            isinstance(n, VariableScope) and any(i.simple_name == name for i in n.names)
+        ) or (isinstance(n, _NESTED_SCOPES) and _mentions(n, name)),
+    )
+
+
+def _enclosing_function(cursor: Cursor) -> Optional[MethodDeclaration]:
+    """The function whose frame alone can observe a block's locals, if there is one.
+
+    A ``try`` or ``with`` between them can catch an exception and read the
+    dict afterwards, so a block inside one has no such function.
+    """
+    for value in islice(cursor.get_path(), 1, None):
+        if isinstance(value, MethodDeclaration):
+            return value
+        if isinstance(value, (Try, ClassDeclaration, CompilationUnit)):
+            return None
+    return None
+
+
+def _is_dead_write(statements: List[Statement], i: int, function: MethodDeclaration) -> bool:
+    """True when the write at ``i`` is overwritten by the next one before anything can see it.
+
+    The dict has to be one only this frame can reach, which rules out other
+    threads, aliases reached through a call, and setter hooks.  The dropped
+    value has to be a constant, so dropping it drops no code.
+    """
+    a = _store(statements[i])
+    b = _store(statements[i + 1])
+    if a is None or b is None:
+        return False
+    name, key, value = a
+    return (
+        b[0] == name
+        and SemanticallyEqual.are_equal(key, b[1])
+        and _is_constant(value)
+        and not _mentions(b[2], name)
+        and _is_fresh_at(statements, i, name)
+        and not _shared_beyond_frame(function, name)
+    )
+
+
+@categorize(_CodeQuality)
+class RemoveUnconditionalValueOverwrite(Recipe):
+    """
+    Remove a dict entry write that the next statement overwrites.
+
+    Only a dict the function has just built and kept to itself qualifies.
+
+    Example:
+        Before:
+            def f():
+                d = {}
+                d["key"] = 1
+                d["key"] = 2
+                return d
+
+        After:
+            def f():
+                d = {}
+                d["key"] = 2
+                return d
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.codequality.RemoveUnconditionalValueOverwrite"
+
+    @property
+    def display_name(self) -> str:
+        return "Remove unconditional value overwrites"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Remove a constant written to a dict key when the next statement "
+            "overwrites the same key. Only a dict the enclosing function built "
+            "with `{...}` or `dict()` and has not yet passed on qualifies, and "
+            "only for constant keys outside `try` and `with` blocks. Writes to "
+            "attributes, parameters and globals are left alone, because "
+            "another thread, an alias or a setter can observe them."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "code-quality", "RSPEC-S4143"]
+
+    @property
+    def estimated_effort_per_occurrence(self) -> int:
+        return 5
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_block(
+                self, block: Block, p: ExecutionContext
+            ) -> Optional[Block]:
+                block = super().visit_block(block, p)
+                if not isinstance(block, Block):
+                    return block
+                function = _enclosing_function(self.cursor)
+                if function is None:
+                    return block
+                removed = _remove_overwrites(block._statements, block.end, function)
+                if removed is not None:
+                    return block.replace(_statements=removed[0], _end=removed[1])
+                return block
+
+        return Visitor()
+
+
+def _removable(padded_statements: list, i: int, function: MethodDeclaration) -> bool:
+    """Return True when the write at ``i`` is dead and can be dropped by splicing lines.
+
+    Both the write and its overwrite have to start a line of their own,
+    which a `;`-joined pair does not.
+    """
+    if i + 1 >= len(padded_statements):
+        return False
+    statements = [s.element for s in padded_statements]
+    if not _is_dead_write(statements, i, function):
+        return False
+    if split_line(statements[i].prefix) is None:
+        return False
+    return split_line(statements[i + 1].prefix) is not None
+
+
+def _remove_overwrites(
+    padded_statements: list, end: Space, function: MethodDeclaration
+) -> 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, function)
+    }
+    if not to_remove:
+        return None
+    return splice_out(padded_statements, end, to_remove)

{openrewrite_migrate_python-0.16.0.dev20261004180356 → openrewrite_migrate_python-0.16.0.dev20261005072603}/src/openrewrite_migrate_python/migrate/string_formatting.py

@@ -304,9 +304,9 @@ def _convert_format_to_fstring(method: MethodInvocation) -> Optional[FormattedSt
                 _markers=Markers.EMPTY,
                 _expression=padded_expr,
                 _debug=None,
-                _conversion=conversion_enum,
+                _conversion=None,
                 _format=format_node,
-            ))
+            ).with_conversion(conversion_enum))
 
     return FormattedString(
         _id=random_id(),
@@ -515,9 +515,9 @@ def _convert_percent_to_fstring(binary: Binary) -> Optional[FormattedString]:
                 _markers=Markers.EMPTY,
                 _expression=padded_expr,
                 _debug=None,
-                _conversion=conversion_enum,
+                _conversion=None,
                 _format=None,
-            ))
+            ).with_conversion(conversion_enum))
 
     return FormattedString(
         _id=random_id(),

{openrewrite_migrate_python-0.16.0.dev20261004180356 → openrewrite_migrate_python-0.16.0.dev20261005072603}/src/openrewrite_migrate_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.16.0.dev20261004180356
+Version: 0.16.0.dev20261005072603
 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.16.0.dev20261004180356/src/openrewrite_code_quality_python/codequality/remove_unconditional_value_overwrite.py

@@ -1,258 +0,0 @@
-"""
-Recipe to remove unconditional overwrites of dict/object values.
-
-When two consecutive statements assign to the same dict key or object
-attribute, the first assignment is dead code -- its value is
-immediately overwritten without ever being read.  Removing it
-eliminates noise and prevents confusion about the author's intent.
-
-See: https://rules.sonarsource.com/python/RSPEC-S4143/
-"""
-
-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 Await, CompilationUnit, ExpressionStatement, YieldFrom
-from rewrite.java.support_types import MethodCall, Space
-from rewrite.java.tree import (
-    ArrayAccess,
-    Assignment,
-    Block,
-    Expression,
-    FieldAccess,
-    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,
-    CategoryDescriptor(display_name="Code quality"),
-]
-
-
-def _get_assignment(stmt: Statement) -> Optional[Assignment]:
-    """Extract an Assignment from a statement, if present."""
-    if isinstance(stmt, ExpressionStatement):
-        expr = stmt.expression
-        if isinstance(expr, Assignment):
-            return expr
-    if isinstance(stmt, Assignment):
-        return stmt
-    return None
-
-
-def _is_subscript_assign(assign: Assignment) -> bool:
-    """Return True if the assignment target is a subscript (d[key])."""
-    return isinstance(assign.variable, ArrayAccess)
-
-
-def _is_attribute_assign(assign: Assignment) -> bool:
-    """Return True if the assignment target is an attribute (obj.x)."""
-    return isinstance(assign.variable, FieldAccess)
-
-
-def _same_subscript_target(a: Assignment, b: Assignment) -> bool:
-    """Return True if both assign to the same dict with the same key."""
-    va = a.variable
-    vb = b.variable
-    if not (isinstance(va, ArrayAccess) and isinstance(vb, ArrayAccess)):
-        return False
-    # Compare the receiver (dict) and the key
-    return (
-        SemanticallyEqual.are_equal(va.indexed, vb.indexed)
-        and SemanticallyEqual.are_equal(va.dimension.index, vb.dimension.index)
-    )
-
-
-def _same_attribute_target(a: Assignment, b: Assignment) -> bool:
-    """Return True if both assign to the same attribute (obj.x)."""
-    va = a.variable
-    vb = b.variable
-    if not (isinstance(va, FieldAccess) and isinstance(vb, FieldAccess)):
-        return False
-    return (
-        va.name.simple_name == vb.name.simple_name
-        and SemanticallyEqual.are_equal(va.target, vb.target)
-    )
-
-
-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):
-        return _same_subscript_target(a, b)
-    if _is_attribute_assign(a) and _is_attribute_assign(b):
-        return _same_attribute_target(a, b)
-    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):
-    """
-    Remove consecutive assignments that write to the same dict key or
-    object attribute.
-
-    When a value written to a collection entry or attribute is
-    immediately overwritten in the very next statement, the first
-    write is dead code.  Removing it keeps the code focused on the
-    value that actually persists.
-
-    Example:
-        Before:
-            d["key"] = 1
-            d["key"] = 2
-
-        After:
-            d["key"] = 2
-    """
-
-    @property
-    def name(self) -> str:
-        return "org.openrewrite.python.codequality.RemoveUnconditionalValueOverwrite"
-
-    @property
-    def display_name(self) -> str:
-        return "Remove unconditional value overwrites"
-
-    @property
-    def description(self) -> str:
-        return (
-            "Remove consecutive assignments that write to the same dict key "
-            "or object attribute, since the first value is immediately "
-            "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
-    def tags(self) -> List[str]:
-        return ["python", "code-quality", "RSPEC-S4143"]
-
-    @property
-    def estimated_effort_per_occurrence(self) -> int:
-        return 5
-
-    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
-        class Visitor(PythonVisitor[ExecutionContext]):
-            def visit_compilation_unit(
-                self, cu: CompilationUnit, p: ExecutionContext
-            ) -> CompilationUnit:
-                cu = super().visit_compilation_unit(cu, p)
-                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
-                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 _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.
-
-    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
-
-
-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
-    return splice_out(padded_statements, end, to_remove)