openrewrite-migrate-python 0.15.2__py3-none-any.whl → 0.16.0__py3-none-any.whl

openrewrite_code_quality_python/__init__.py

@@ -21,15 +21,15 @@ def activate(marketplace: RecipeMarketplace) -> None:
     """
     from rewrite.decorators import get_recipe_category
 
+    from . import cleanup as cleanup_pkg
     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)
+    # Auto-discover all Recipe subclasses from the codequality and cleanup packages
+    for pkg in (codequality_pkg, cleanup_pkg):
+        for module_info in pkgutil.walk_packages(pkg.__path__, prefix=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_code_quality_python/cleanup/__init__.py

@@ -0,0 +1,207 @@
+"""Python cleanup recipes."""
+
+from .assign_return import RemoveUnnecessaryAssign
+from .attr_access import (
+    ReplaceGetAttrWithConstant,
+    ReplaceSetAttrWithConstant,
+)
+from .boolean_simplification import (
+    BooleanIfExpIdentity,
+    CollectionToBool,
+    DeMorgan,
+    RemoveRedundantBoolean,
+    SimplifyBooleanReturn,
+    SimplifyLenComparison,
+)
+from .collection_literals import (
+    CollectionIntoSet,
+    DictLiteral,
+    ListLiteral,
+    TupleLiteral,
+    UnwrapIterableConstruction,
+)
+from .comparison_simplification import (
+    ChainCompares,
+    MergeComparisons,
+    SimplifySubstringSearch,
+)
+from .complex_transforms import (
+    SwapVariable,
+    TernaryToIfExpression,
+)
+from .comprehension_cleanup import (
+    CollectionBuiltinToComprehension,
+    ComprehensionToGenerator,
+    ConvertAnyToIn,
+    IdentityComprehension,
+    InvertAnyAll,
+    InvertAnyAllBody,
+    SimplifyConstantSum,
+    SimplifyGenerator,
+)
+from .conditionals import (
+    AssignIfExp,
+    MergeElseIfIntoElif,
+    MergeIsinstance,
+    RemovePassElif,
+    RemoveRedundantIf,
+    RemoveUnnecessaryElse,
+    SwapIfElseBranches,
+)
+from .datetime_cleanup import UseDatetimeNowNotToday
+from .dict_cleanup import (
+    RemoveDictKeys,
+    RemoveDuplicateDictKey,
+    RemoveDuplicateSetKey,
+    RemoveRedundantConstructorInDictUnion,
+    SimplifyDictionaryUpdate,
+    UseDictionaryUnion,
+)
+from .exception_cleanup import (
+    RaiseFromPreviousError,
+    SimplifySingleExceptionTuple,
+)
+from .expression_simplification import (
+    AugAssign,
+    OrIfExpIdentity,
+    RemoveRedundantSliceIndex,
+    SimplifyNegativeIndex,
+    SwapIfExpression,
+)
+from .logger_warn import ReplaceLoggerWarn
+from .loop_cleanup import UselessElseOnLoop
+from .merge_nested_with import MergeNestedWithStatements
+from .merge_startswith_endswith import MergeStartswithEndswith
+from .naming_conventions import (
+    ClassMethodFirstArgName,
+    InstanceMethodFirstArgName,
+)
+from .negated_operators import (
+    ReplaceNotInTest,
+    ReplaceNotIsTest,
+)
+from .none_and_identity import (
+    BinOpIdentity,
+    EqualityIdentity,
+    NoneCompare,
+    SquareIdentity,
+)
+from .object_inheritance import RemoveUselessObjectInheritance
+from .pandas_cleanup import (
+    DataframeAppendToConcat,
+    ReplaceApplyWithMethodCall,
+)
+from .python_best_practices import PythonBestPractices
+from .range_cleanup import (
+    RemoveUnitStepFromRange,
+    RemoveZeroFromRange,
+)
+from .redundant_code import (
+    RemoveRedundantContinue,
+    RemoveRedundantPathExists,
+)
+from .remove_trailing_return_none import RemoveTrailingReturnNone
+from .string_cleanup import (
+    RemoveNoneFromDefaultGet,
+    RemoveRedundantFstring,
+    RemoveStrFromFstring,
+    RemoveStrFromPrint,
+    SimplifyFstringFormatting,
+    StrPrefixSuffix,
+    UseGetitemForReMatchGroups,
+    UseStringRemoveAffix,
+)
+from .unreachable_code import (
+    RemoveAssertTrue,
+    RemoveEmptyNestedBlock,
+    RemoveUnreachableCode,
+)
+from .use_items import UseItemsForKeyValueIteration
+from .use_list_clear import UseListClear
+from .yoda_conditions import ReplaceYodaConditions
+
+__all__ = [
+    "AssignIfExp",
+    "AugAssign",
+    "BinOpIdentity",
+    "BooleanIfExpIdentity",
+    "ChainCompares",
+    "ClassMethodFirstArgName",
+    "CollectionBuiltinToComprehension",
+    "CollectionIntoSet",
+    "CollectionToBool",
+    "ComprehensionToGenerator",
+    "ConvertAnyToIn",
+    "DataframeAppendToConcat",
+    "DeMorgan",
+    "DictLiteral",
+    "EqualityIdentity",
+    "IdentityComprehension",
+    "InstanceMethodFirstArgName",
+    "InvertAnyAll",
+    "InvertAnyAllBody",
+    "ListLiteral",
+    "MergeComparisons",
+    "MergeElseIfIntoElif",
+    "MergeIsinstance",
+    "MergeNestedWithStatements",
+    "MergeStartswithEndswith",
+    "NoneCompare",
+    "OrIfExpIdentity",
+    "PythonBestPractices",
+    "RaiseFromPreviousError",
+    "RemoveAssertTrue",
+    "RemoveDictKeys",
+    "RemoveDuplicateDictKey",
+    "RemoveDuplicateSetKey",
+    "RemoveEmptyNestedBlock",
+    "RemoveNoneFromDefaultGet",
+    "RemovePassElif",
+    "RemoveRedundantBoolean",
+    "RemoveRedundantConstructorInDictUnion",
+    "RemoveRedundantContinue",
+    "RemoveRedundantFstring",
+    "RemoveRedundantIf",
+    "RemoveRedundantPathExists",
+    "RemoveRedundantSliceIndex",
+    "RemoveStrFromFstring",
+    "RemoveStrFromPrint",
+    "RemoveTrailingReturnNone",
+    "RemoveUnitStepFromRange",
+    "RemoveUnnecessaryAssign",
+    "RemoveUnnecessaryElse",
+    "RemoveUnreachableCode",
+    "RemoveUselessObjectInheritance",
+    "RemoveZeroFromRange",
+    "ReplaceApplyWithMethodCall",
+    "ReplaceGetAttrWithConstant",
+    "ReplaceLoggerWarn",
+    "ReplaceNotInTest",
+    "ReplaceNotIsTest",
+    "ReplaceSetAttrWithConstant",
+    "ReplaceYodaConditions",
+    "SimplifyBooleanReturn",
+    "SimplifyConstantSum",
+    "SimplifyDictionaryUpdate",
+    "SimplifyFstringFormatting",
+    "SimplifyGenerator",
+    "SimplifyLenComparison",
+    "SimplifyNegativeIndex",
+    "SimplifySingleExceptionTuple",
+    "SimplifySubstringSearch",
+    "SquareIdentity",
+    "StrPrefixSuffix",
+    "SwapIfElseBranches",
+    "SwapIfExpression",
+    "SwapVariable",
+    "TernaryToIfExpression",
+    "TupleLiteral",
+    "UnwrapIterableConstruction",
+    "UseDatetimeNowNotToday",
+    "UseDictionaryUnion",
+    "UseGetitemForReMatchGroups",
+    "UseItemsForKeyValueIteration",
+    "UseListClear",
+    "UseStringRemoveAffix",
+    "UselessElseOnLoop",
+]

openrewrite_code_quality_python/cleanup/_literals.py

@@ -0,0 +1,23 @@
+"""Classify literals by their source text, which tells `str` from `bytes` where the type does not."""
+
+from typing import Any
+
+from rewrite.java.tree import Literal
+
+
+def _prefix(source: str) -> str:
+    return source[:len(source) - len(source.lstrip("bBrRuU"))]
+
+
+def is_string_literal(expr: Any) -> bool:
+    """Whether ``expr`` is a ``str`` or ``bytes`` literal, prefixed or not."""
+    if not isinstance(expr, Literal) or not expr.value_source:
+        return False
+    source = expr.value_source
+    prefix = _prefix(source)
+    return len(prefix) <= 2 and source[len(prefix):len(prefix) + 1] in ('"', "'")
+
+
+def is_bytes_literal(expr: Literal) -> bool:
+    """Whether ``expr`` is a ``b``-prefixed literal, which the parser types as ``str``."""
+    return "b" in _prefix(expr.value_source or "").lower()

openrewrite_code_quality_python/cleanup/assign_return.py

@@ -0,0 +1,153 @@
+"""Recipe for RET504: Remove unnecessary assignment before return.
+
+Detects the pattern where a variable is assigned and then immediately
+returned, replacing it with a direct return of the expression.
+
+Example:
+    Before:
+        def foo():
+            x = expr
+            return x
+
+    After:
+        def foo():
+            return expr
+
+See: https://docs.astral.sh/ruff/rules/unnecessary-assign/
+"""
+
+from typing import Any, List
+
+from rewrite import ExecutionContext, Recipe, TreeVisitor
+from rewrite.category import CategoryDescriptor
+from rewrite.decorators import categorize
+from rewrite.execution import InMemoryExecutionContext
+from rewrite.marketplace import Python
+from rewrite.python.tree import StatementExpression
+from rewrite.python.visitor import PythonVisitor
+from rewrite.java.tree import Assignment, Block, Identifier, J, MethodDeclaration, Return
+
+
+_Cleanup = [*Python, CategoryDescriptor(display_name="Cleanup")]
+
+
+@categorize(_Cleanup)
+class RemoveUnnecessaryAssign(Recipe):
+    """
+    Remove unnecessary variable assignment before return.
+
+    When a variable is assigned a value and then immediately returned
+    with no other uses, the assignment is unnecessary and the expression
+    can be returned directly.
+
+    Example:
+        Before:
+            def foo():
+                result = compute()
+                return result
+
+        After:
+            def foo():
+                return compute()
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.cleanup.RemoveUnnecessaryAssign"
+
+    @property
+    def display_name(self) -> str:
+        return "Remove unnecessary assignment before return"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Return the value directly where a variable is assigned and then "
+            "immediately returned. A name that appears anywhere else in "
+            "the function, a `yield` value, and a comment before the `return` are left alone."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "cleanup", "ruff", "RET504"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_block(self, block: Block, p: ExecutionContext) -> J:
+                visited = super().visit_block(block, p)
+                if not isinstance(visited, Block):
+                    return visited
+                block = visited
+
+                stmts = block.statements
+                if len(stmts) < 2:
+                    return block
+
+                # Only check the last two statements in the block
+                i = len(stmts) - 2
+                assign_stmt = stmts[i]
+                return_stmt = stmts[i + 1]
+
+                if not isinstance(assign_stmt, Assignment):
+                    return block
+                if not isinstance(return_stmt, Return):
+                    return block
+
+                # Check that the assignment target is a simple identifier
+                if not isinstance(assign_stmt.variable, Identifier):
+                    return block
+                assign_name = assign_stmt.variable.simple_name
+
+                # Check that the return expression is the same identifier
+                returned = return_stmt.expression
+                if not isinstance(returned, Identifier) or returned.simple_name != assign_name:
+                    return block
+
+                # A handler, a closure or a global/nonlocal binding may read the value,
+                # so only the assignment and the return may name it.
+                method = self.cursor.first_enclosing(MethodDeclaration)
+                if method is None or count_mentions(method, assign_name) != 2:
+                    return block
+                if isinstance(assign_stmt.assignment, StatementExpression):
+                    return block
+                if return_stmt.prefix.comments:
+                    return block
+
+                # Build the new return statement with the assignment's RHS
+                # Preserve the prefix (whitespace) from the assignment statement
+                rhs = assign_stmt.assignment
+                new_return = return_stmt.replace(
+                    _prefix=assign_stmt.prefix,
+                    _expression=rhs,
+                )
+
+                # Build new padded statement list: remove assignment, replace return
+                padded_stmts = block.padding.statements
+                new_padded = []
+                for j, ps in enumerate(padded_stmts):
+                    if j == i:
+                        continue
+                    elif j == i + 1:
+                        new_padded.append(ps.replace(element=new_return))
+                    else:
+                        new_padded.append(ps)
+
+                return block.padding.replace(_statements=new_padded)
+
+        return Visitor()
+
+
+def count_mentions(tree: J, name: str) -> int:
+    """How many identifiers in ``tree`` spell ``name``."""
+
+    class NameCounter(PythonVisitor[ExecutionContext]):
+        count = 0
+
+        def visit_identifier(self, ident: Identifier, p: ExecutionContext) -> J:
+            if ident.simple_name == name:
+                self.count += 1
+            return ident
+
+    counter = NameCounter()
+    counter.visit(tree, InMemoryExecutionContext())
+    return counter.count

openrewrite_code_quality_python/cleanup/attr_access.py

@@ -0,0 +1,234 @@
+"""
+Recipes that replace ``getattr()`` / ``setattr()`` calls with direct attribute
+access or assignment when the attribute name is a constant valid identifier.
+
+- ``getattr(x, "attr")`` becomes ``x.attr`` (B009)
+- ``setattr(x, "attr", val)`` becomes ``x.attr = val`` (B010)
+
+See:
+- https://docs.astral.sh/ruff/rules/getattr-with-constant/
+- https://docs.astral.sh/ruff/rules/set-attr-with-constant/
+"""
+
+import keyword
+from functools import lru_cache
+from typing import Any, List, Optional
+
+from rewrite import ExecutionContext, Preconditions, Recipe, TreeVisitor
+from rewrite.category import CategoryDescriptor
+from rewrite.decorators import categorize
+from rewrite.markers import Markers
+from rewrite.marketplace import Python
+from rewrite.python.method_matcher import MethodMatcher
+from rewrite.python.preconditions import uses_method
+from rewrite.python.visitor import PythonVisitor
+from rewrite.python.template import Template, template, capture
+from rewrite.java.support_types import JLeftPadded, Space
+from rewrite.java.tree import (
+    ArrayAccess,
+    Block,
+    FieldAccess,
+    Identifier,
+    J,
+    Literal,
+    MethodInvocation,
+    Parentheses,
+)
+from rewrite.python.tree import CompilationUnit
+from rewrite.utils import random_id
+
+from openrewrite_code_quality_python.codequality._side_effects import is_side_effect_free
+from openrewrite_code_quality_python.codequality._trivia import has_comments
+
+_Cleanup = [*Python, CategoryDescriptor(display_name="Cleanup")]
+
+_GETATTR_PATTERN = "builtins getattr(..)"
+_SETATTR_PATTERN = "builtins setattr(..)"
+_GETATTR = MethodMatcher.create(_GETATTR_PATTERN)
+_SETATTR = MethodMatcher.create(_SETATTR_PATTERN)
+
+_obj = capture('obj')
+_val = capture('val')
+
+
+@lru_cache(maxsize=None)
+def _assignment_template(attr_name: str) -> Template:
+    return template(f"{_obj}.{attr_name} = {_val}")
+
+
+def _constant_attribute_name(method: MethodInvocation) -> Optional[str]:
+    """The attribute name a builtin ``getattr``/``setattr`` call spells as a literal,
+    when attribute syntax reads the same attribute."""
+    attr_arg = method.arguments[1]
+    attr_name = attr_arg.value if isinstance(attr_arg, Literal) else None
+    if (
+        not isinstance(attr_name, str)
+        or not attr_name.isidentifier()
+        or keyword.iskeyword(attr_name)
+        # Attribute syntax NFKC-normalizes a non-ASCII name, `getattr` does not.
+        or not attr_name.isascii()
+        # Inside a class `self.__x` is mangled to `self._Class__x`, but
+        # `getattr(self, "__x")` looks up the literal `__x`.
+        or (attr_name.startswith('__') and not attr_name.endswith('__'))
+        or has_comments(method.replace(_prefix=Space.EMPTY))
+    ):
+        return None
+    return attr_name
+
+
+@categorize(_Cleanup)
+class ReplaceGetAttrWithConstant(Recipe):
+    """
+    Replace `getattr(x, "attr")` with `x.attr`.
+
+    The `getattr()` builtin with a constant string attribute name that is a
+    valid Python identifier can be replaced with direct attribute access for
+    clarity and brevity.
+
+    Only applies when:
+    - There are exactly 2 arguments (no default value)
+    - The second argument is a string literal
+    - The string value is an ASCII Python identifier (not a keyword)
+    - The object is a name, attribute, call, subscript or parenthesized expression
+
+    Example:
+        Before:
+            result = getattr(obj, "name")
+
+        After:
+            result = obj.name
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.cleanup.ReplaceGetAttrWithConstant"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `getattr(x, 'attr')` with `x.attr`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Replace `getattr(x, \"attr\")` calls with `x.attr` when the attribute "
+            "name is a constant string that is a valid Python identifier. "
+            "It leaves alone a shadowed `getattr`, a non-ASCII or name-mangled name, "
+            "an object that would need parentheses, and a call holding comments."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "cleanup", "ruff", "B009"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_method_invocation(
+                self, method: MethodInvocation, p: ExecutionContext
+            ) -> J:
+                m = super().visit_method_invocation(method, p)
+                if (
+                    not isinstance(m, MethodInvocation)
+                    or not _GETATTR.matches(m, cursor=self.cursor)
+                    or len(m.arguments) != 2
+                ):
+                    return m
+                attr_name = _constant_attribute_name(m)
+                obj_expr = m.arguments[0]
+                if attr_name is None or not isinstance(
+                    obj_expr, (Identifier, FieldAccess, MethodInvocation, ArrayAccess, Parentheses)
+                ):
+                    return m
+
+                attr_identifier = Identifier(
+                    _id=random_id(),
+                    _prefix=Space.EMPTY,
+                    _markers=Markers.EMPTY,
+                    _annotations=[],
+                    _simple_name=attr_name,
+                    _type=None,
+                    _field_type=None,
+                )
+                return FieldAccess(
+                    _id=random_id(),
+                    _prefix=m.prefix,
+                    _markers=Markers.EMPTY,
+                    _target=obj_expr.replace(_prefix=Space.EMPTY),
+                    _name=JLeftPadded(
+                        _before=Space.EMPTY,
+                        _element=attr_identifier,
+                        _markers=Markers.EMPTY,
+                    ),
+                    _type=None,
+                )
+
+        return Preconditions.check(uses_method(_GETATTR_PATTERN), Visitor())
+
+
+@categorize(_Cleanup)
+class ReplaceSetAttrWithConstant(Recipe):
+    """
+    Replace `setattr(x, "attr", value)` with `x.attr = value`.
+
+    When `setattr()` is called as a statement with a constant string attribute
+    name that is a valid Python identifier, it can be replaced with a direct
+    attribute assignment for better readability.
+
+    Example:
+        Before:
+            setattr(obj, "name", value)
+
+        After:
+            obj.name = value
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.cleanup.ReplaceSetAttrWithConstant"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `setattr()` with constant attribute assignment"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Replace a `setattr(x, \"attr\", value)` statement with `x.attr = value` "
+            "when the attribute name is a constant valid Python identifier. "
+            "It leaves alone a shadowed `setattr`, a non-ASCII or name-mangled name, "
+            "a call used as an expression, a call holding comments, and an object or value "
+            "that may have side effects, since the assignment evaluates the value first."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "cleanup", "ruff", "B010"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_method_invocation(
+                self, method: MethodInvocation, p: ExecutionContext
+            ) -> J:
+                m = super().visit_method_invocation(method, p)
+                if (
+                    not isinstance(m, MethodInvocation)
+                    or not _SETATTR.matches(m, cursor=self.cursor)
+                    or len(m.arguments) != 3
+                    or not isinstance(
+                        self.cursor.parent_tree_cursor().value, (Block, CompilationUnit)
+                    )
+                ):
+                    return m
+                attr_name = _constant_attribute_name(m)
+                obj_expr, _, val_expr = m.arguments
+                if (
+                    attr_name is None
+                    or not is_side_effect_free(obj_expr)
+                    or not is_side_effect_free(val_expr)
+                ):
+                    return m
+
+                return _assignment_template(attr_name).apply(
+                    self.cursor, values={'obj': obj_expr, 'val': val_expr}
+                ) or m
+
+        return Preconditions.check(uses_method(_SETATTR_PATTERN), Visitor())