openrewrite-migrate-python 0.5.0.dev20260407172149__tar.gz → 0.6.0__tar.gz

{openrewrite_migrate_python-0.5.0.dev20260407172149 → openrewrite_migrate_python-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.5.0.dev20260407172149
+Version: 0.6.0
 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.5.0.dev20260407172149 → openrewrite_migrate_python-0.6.0}/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.5.0.dev20260407172149"  # Updated dynamically during release
+version = "0.6.0"  # Updated dynamically during release
 authors = [{ name = "Moderne Inc.", email = "support@moderne.io" }]
 license = { text = "Moderne Proprietary" }
 readme = "README.md"
@@ -49,10 +49,11 @@ Issues = "https://github.com/openrewrite/rewrite-migrate-python/issues"
 
 [project.entry-points."openrewrite.recipes"]
 migrate_python = "openrewrite_migrate_python:activate"
+code_quality_python = "openrewrite_code_quality_python:activate"
 
 [tool.setuptools.packages.find]
 where = ["src"]
-include = ["openrewrite_migrate_python", "openrewrite_migrate_python.*"]
+include = ["openrewrite_migrate_python", "openrewrite_migrate_python.*", "openrewrite_code_quality_python", "openrewrite_code_quality_python.*"]
 
 [tool.setuptools.package-data]
 "*" = ["py.typed", "*.pyi"]

openrewrite_migrate_python-0.6.0/src/openrewrite_code_quality_python/__init__.py

@@ -0,0 +1,35 @@
+"""OpenRewrite recipes for Python code quality improvements."""
+
+import importlib
+import inspect
+import pkgutil
+
+from rewrite import Recipe, RecipeMarketplace
+
+__all__ = ["activate"]
+
+
+def activate(marketplace: RecipeMarketplace) -> None:
+    """
+    Install all code quality recipes into the marketplace.
+
+    This function is called by the OpenRewrite discovery mechanism when the
+    openrewrite-code-quality-python package is found via entry points.
+
+    Args:
+        marketplace: The RecipeMarketplace to install recipes into
+    """
+    from rewrite.decorators import get_recipe_category
+
+    from . import codequality as codequality_pkg
+
+    # Auto-discover all Recipe subclasses from the codequality package
+    for module_info in pkgutil.walk_packages(
+        codequality_pkg.__path__, prefix=codequality_pkg.__name__ + "."
+    ):
+        module = importlib.import_module(module_info.name)
+        for _name, obj in inspect.getmembers(module, inspect.isclass):
+            if issubclass(obj, Recipe) and obj is not Recipe and obj.__module__ == module.__name__:
+                category = get_recipe_category(obj)
+                if category is not None:
+                    marketplace.install(obj, category)

openrewrite_migrate_python-0.6.0/src/openrewrite_code_quality_python/codequality/__init__.py

@@ -0,0 +1,23 @@
+"""Python code quality recipes."""
+
+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
+
+__all__ = [
+    "AllBranchesIdentical",
+    "BooleanChecksNotInverted",
+    "CollapsibleIfStatements",
+    "MergeIdenticalBranches",
+    "RemoveDuplicateConditions",
+    "RemoveSelfAssignment",
+    "RemoveUnconditionalValueOverwrite",
+    "SimplifyBooleanLiteral",
+    "SimplifyRedundantLogicalExpression",
+]

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

@@ -0,0 +1,32 @@
+"""
+Structural equality comparison for LST nodes.
+
+Compares two tree nodes by printing them with normalized whitespace
+and checking that the printed representations match. This provides
+the same functionality as ``SemanticallyEqual`` from the Java SDK.
+"""
+
+from rewrite.java.support_types import Space
+from rewrite.python.printer import PythonPrinter
+
+_printer = PythonPrinter()
+
+
+class SemanticallyEqual:
+    """Compare two LST nodes for structural equality."""
+
+    @staticmethod
+    def are_equal(a, b) -> bool:
+        """Return True if *a* and *b* are semantically equal.
+
+        Both nodes are printed after stripping their leading prefix so
+        that insignificant whitespace differences are ignored.
+        """
+        if a is None and b is None:
+            return True
+        if a is None or b is None:
+            return False
+        return (
+            _printer.print(a.replace(_prefix=Space.EMPTY))
+            == _printer.print(b.replace(_prefix=Space.EMPTY))
+        )

openrewrite_migrate_python-0.6.0/src/openrewrite_code_quality_python/codequality/all_branches_identical.py

@@ -0,0 +1,206 @@
+"""
+Recipe to replace if/elif/else chains where every branch has the same body.
+
+When all branches of a conditional execute identical code the condition
+is meaningless.  The entire ``if``/``elif``/``else`` chain can be
+replaced with a single copy of the body, removing unnecessary
+complexity and making it obvious that the code always runs.
+
+See: https://rules.sonarsource.com/python/RSPEC-S3923/
+"""
+
+from typing import Any, List, Optional
+
+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.java.support_types import Space
+from rewrite.java.tree import (
+    Block,
+    If,
+    Statement,
+)
+from openrewrite_code_quality_python.codequality._semantically_equal import SemanticallyEqual
+
+_CodeQuality = [
+    *Python,
+    CategoryDescriptor(display_name="Code quality"),
+]
+
+
+def _has_explicit_else(if_: If) -> bool:
+    """Return True if the chain ends with a plain ``else`` (not elif)."""
+    current = if_
+    while True:
+        else_part = current.else_part
+        if else_part is None:
+            return False
+        branch = else_part.body
+        if isinstance(branch, If):
+            current = branch
+        else:
+            # Reached a plain else block
+            return True
+
+
+def _collect_bodies(if_: If) -> list[Statement]:
+    """Collect the then-part of every branch including the final else."""
+    bodies: list[Statement] = [if_.then_part]
+    current = if_
+    while True:
+        else_part = current.else_part
+        if else_part is None:
+            break
+        branch = else_part.body
+        if isinstance(branch, If):
+            bodies.append(branch.then_part)
+            current = branch
+        else:
+            # Plain else body
+            bodies.append(branch)
+            break
+    return bodies
+
+
+def _all_bodies_equal(bodies: list[Statement]) -> bool:
+    """Return True when every body is semantically equal to the first."""
+    if len(bodies) < 2:
+        return False
+    first = bodies[0]
+    return all(
+        SemanticallyEqual.are_equal(first, body)
+        for body in bodies[1:]
+    )
+
+
+@categorize(_CodeQuality)
+class AllBranchesIdentical(Recipe):
+    """
+    Replace ``if``/``elif``/``else`` chains where every branch has
+    the same body with just the body.
+
+    When every branch of a conditional executes identical code, the
+    condition serves no purpose.  Removing it makes the code shorter
+    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.
+
+    Example:
+        Before:
+            if cond:
+                x()
+            else:
+                x()
+
+        After:
+            x()
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.codequality.AllBranchesIdentical"
+
+    @property
+    def display_name(self) -> str:
+        return "Remove conditional with identical branches"
+
+    @property
+    def description(self) -> str:
+        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."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "code-quality", "RSPEC-S3923"]
+
+    @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, p):
+                cu = super().visit_compilation_unit(cu, p)
+                new_stmts = _replace_identical_ifs_padded(cu._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)
+                if new_stmts is not None:
+                    return block.replace(_statements=new_stmts)
+                return block
+
+        return Visitor()
+
+
+def _replace_identical_ifs_padded(padded_stmts) -> Optional[list]:
+    """Replace if/elif/else with identical branches with just the body.
+
+    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:
+        s = rp.element
+        if not isinstance(s, If):
+            result.append(rp)
+            continue
+        if not _has_explicit_else(s):
+            result.append(rp)
+            continue
+        bodies = _collect_bodies(s)
+        if not _all_bodies_equal(bodies):
+            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:
+            result.append(rp)
+
+    if not changed:
+        return None
+    return result

openrewrite_migrate_python-0.6.0/src/openrewrite_code_quality_python/codequality/boolean_checks_not_inverted.py

@@ -0,0 +1,123 @@
+"""
+Recipe to simplify inverted boolean checks.
+
+Negating a comparison operator is harder to read than using the
+opposite operator directly. For example, ``not (a == b)`` is clearer
+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 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.java.support_types import JLeftPadded, Space
+from rewrite.java.tree import (
+    Binary as JBinary,
+    Expression,
+    Parentheses,
+    Unary,
+)
+
+_CodeQuality = [
+    *Python,
+    CategoryDescriptor(display_name="Code quality"),
+]
+
+_OPERATOR_INVERSE = {
+    JBinary.Type.Equal: JBinary.Type.NotEqual,
+    JBinary.Type.NotEqual: JBinary.Type.Equal,
+    JBinary.Type.LessThan: JBinary.Type.GreaterThanOrEqual,
+    JBinary.Type.GreaterThan: JBinary.Type.LessThanOrEqual,
+    JBinary.Type.LessThanOrEqual: JBinary.Type.GreaterThan,
+    JBinary.Type.GreaterThanOrEqual: JBinary.Type.LessThan,
+}
+
+
+@categorize(_CodeQuality)
+class BooleanChecksNotInverted(Recipe):
+    """
+    Replace inverted boolean checks with the equivalent direct comparison.
+
+    Writing ``not (a == b)`` obscures the intent when ``a != b`` says the
+    same thing more directly. Likewise ``not (not x)`` is simply ``x``.
+    Flipping the operator or removing the double negation makes the
+    condition immediately obvious to the reader.
+
+    Example:
+        Before:
+            if not (a == b):
+                pass
+
+        After:
+            if a != b:
+                pass
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.codequality.BooleanChecksNotInverted"
+
+    @property
+    def display_name(self) -> str:
+        return "Boolean checks should not be inverted"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Replace inverted boolean comparisons like `not (a == b)` with the "
+            "equivalent direct operator (`a != b`), and remove double negations "
+            "like `not (not x)`."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "code-quality", "RSPEC-S1940"]
+
+    @property
+    def estimated_effort_per_occurrence(self) -> int:
+        return 2
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        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
+
+                if unary.operator != Unary.Type.Not:
+                    return unary
+
+                expr = unary.expression
+
+                # Unwrap parentheses to inspect inner expression
+                inner = expr
+                if isinstance(inner, Parentheses):
+                    inner = inner.tree
+
+                # Double negation: not (not x) -> x
+                if isinstance(inner, Unary) and inner.operator == Unary.Type.Not:
+                    return inner.expression.replace(_prefix=unary.prefix)
+
+                # Inverted comparison: not (a == b) -> a != b
+                if isinstance(inner, JBinary):
+                    inverse = _OPERATOR_INVERSE.get(inner.operator)
+                    if inverse is not None:
+                        return inner.padding.replace(
+                            _operator=JLeftPadded(
+                                _before=inner.padding.operator.before,
+                                _element=inverse,
+                                _markers=inner.padding.operator.markers,
+                            )
+                        ).replace(_prefix=unary.prefix)
+
+                return unary
+
+        return Visitor()

openrewrite_migrate_python-0.6.0/src/openrewrite_code_quality_python/codequality/collapsible_if_statements.py

@@ -0,0 +1,195 @@
+"""
+Recipe to merge collapsible ``if`` statements.
+
+When an ``if`` block contains only another ``if`` and neither has an
+``else`` branch, the two conditions can be combined with ``and`` into
+a single ``if``. This reduces nesting and makes the control flow
+easier to follow.
+
+See: https://rules.sonarsource.com/python/RSPEC-S1066/
+"""
+
+from typing import Any, List, Optional
+
+from rewrite import ExecutionContext, Recipe, TreeVisitor
+from rewrite.category import CategoryDescriptor
+from rewrite.decorators import categorize
+from rewrite.marketplace import Python
+from rewrite.markers import Markers
+from rewrite.python.visitor import PythonVisitor
+from rewrite.java.support_types import JLeftPadded, JRightPadded, Space
+from rewrite.java.tree import (
+    Binary as JBinary,
+    Block,
+    ControlParentheses,
+    Expression,
+    If,
+    Parentheses,
+)
+from rewrite.utils import random_id
+
+_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 _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)
+
+
+@categorize(_CodeQuality)
+class CollapsibleIfStatements(Recipe):
+    """
+    Merge nested ``if`` statements into a single ``if`` with ``and``.
+
+    An ``if`` whose body is nothing but another ``if``--and neither has
+    an ``else`` clause--can always be rewritten as one ``if`` that
+    combines both conditions with ``and``. The merged form is shorter,
+    has less indentation, and communicates the same logic.
+
+    Example:
+        Before:
+            if a:
+                if b:
+                    do_something()
+
+        After:
+            if a and b:
+                do_something()
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.codequality.CollapsibleIfStatements"
+
+    @property
+    def display_name(self) -> str:
+        return "Merge collapsible if statements"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Combine nested `if` statements that have no `else` branch into "
+            "a single `if` joined with `and`."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "code-quality", "RSPEC-S1066"]
+
+    @property
+    def estimated_effort_per_occurrence(self) -> int:
+        return 5
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_if(
+                self, if_: If, p: ExecutionContext
+            ) -> Optional[If]:
+                if_ = super().visit_if(if_, p)
+
+                if not isinstance(if_, If):
+                    return if_
+
+                # Outer if must have no else/elif
+                if if_.else_part is not None:
+                    return if_
+
+                then = if_.then_part
+                if not isinstance(then, Block):
+                    return if_
+
+                stmts = then.statements
+                if len(stmts) != 1:
+                    return if_
+
+                inner = stmts[0]
+                if not isinstance(inner, If):
+                    return if_
+
+                # Inner if must have no else/elif
+                if inner.else_part is not None:
+                    return if_
+
+                outer_cond = if_.if_condition.tree
+                inner_cond = inner.if_condition.tree
+
+                # 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)
+
+                combined = JBinary(
+                    _id=random_id(),
+                    _prefix=outer_cond.prefix,
+                    _markers=Markers.EMPTY,
+                    _left=outer_cond.replace(_prefix=Space.EMPTY),
+                    _operator=JLeftPadded(
+                        _before=Space.SINGLE_SPACE,
+                        _element=JBinary.Type.And,
+                        _markers=Markers.EMPTY,
+                    ),
+                    _right=inner_cond,
+                    _type=None,
+                )
+
+                new_condition = ControlParentheses(
+                    _id=if_.if_condition.id,
+                    _prefix=if_.if_condition.prefix,
+                    _markers=if_.if_condition.markers,
+                    _tree=JRightPadded(
+                        _element=combined,
+                        _after=if_.if_condition.padding.tree.after,
+                        _markers=if_.if_condition.padding.tree.markers,
+                    ),
+                )
+
+                # 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)
+
+                return if_.replace(
+                    _if_condition=new_condition,
+                ).padding.replace(
+                    _then_part=JRightPadded(
+                        _element=inner_body,
+                        _after=if_.padding.then_part.after,
+                        _markers=if_.padding.then_part.markers,
+                    ),
+                )
+
+        return Visitor()