openrewrite-migrate-python 0.14.0.dev20260902102558__tar.gz → 0.14.0.dev20260902122728__tar.gz

{openrewrite_migrate_python-0.14.0.dev20260902102558 → openrewrite_migrate_python-0.14.0.dev20260902122728}/PKG-INFO

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

@@ -0,0 +1,275 @@
+"""
+Recipe to remove self-assignments.
+
+Assigning a plain local name to itself (``x = x``) has no effect and is
+almost always a copy-paste error or leftover from a refactoring.
+Removing these statements makes the code cleaner and avoids
+confusion about the author's intent.
+
+See: https://rules.sonarsource.com/python/RSPEC-S1656/
+"""
+
+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.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,
+)
+
+_CodeQuality = [
+    *Python,
+    CategoryDescriptor(display_name="Code quality"),
+]
+
+
+def _is_local_self_assignment(statement: Statement) -> bool:
+    """Return True for ``x = x`` on a plain name.
+
+    Only a plain name is a no-op.  ``obj.x = obj.x`` and ``d[k] = d[k]``
+    read *and* write through ``__set__``/``__setitem__``, and the other
+    assignment shapes (``x: int = x``, ``x = y = y``, ``x += x``) parse to
+    node types this deliberately does not match.
+    """
+    if not isinstance(statement, Assignment):
+        return False
+    target, value = statement.variable, statement.assignment
+    return (
+        isinstance(target, Identifier)
+        and isinstance(value, Identifier)
+        and target.simple_name == value.simple_name
+    )
+
+
+def _in_function_scope(cursor: Cursor) -> bool:
+    """Return True when the block at ``cursor`` belongs to a function.
+
+    ``X = X`` is a no-op only where both sides bind the same name.  In a
+    class body or at module scope the right-hand side reads an enclosing
+    binding while the left-hand side creates a new one, so the statement
+    is what publishes the name.
+    """
+    for value in islice(cursor.get_path(), 1, None):
+        if isinstance(value, MethodDeclaration):
+            return True
+        if isinstance(value, (ClassDeclaration, CompilationUnit)):
+            return False
+    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:
+    """Return True when statement ``i`` can be dropped without disturbing its neighbours.
+
+    The removal is expressed by splicing line-level trivia, so the statement
+    has to occupy a line of its own, and so does whatever the printer emits
+    next -- either the following statement or, for the last one, the trivia
+    after the block.  A last statement whose line ends in a comment stays:
+    that comment is held outside the block, out of reach.
+    """
+    if not _is_local_self_assignment(padded_statements[i].element):
+        return False
+    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)
+
+
+def _remove_self_assignments(
+    padded_statements: list, end: Space, 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 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)
+
+
+@categorize(_CodeQuality)
+class RemoveSelfAssignment(Recipe):
+    """
+    Remove assignments of a plain local name to itself.
+
+    A self-assignment like ``x = x`` inside a function does nothing at
+    runtime.  These statements typically result from copy-paste mistakes
+    or incomplete refactorings and should be deleted to keep the code
+    clear.
+
+    Example:
+        Before:
+            x = x
+
+        After:
+            (statement removed)
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.codequality.RemoveSelfAssignment"
+
+    @property
+    def display_name(self) -> str:
+        return "Remove self-assignments"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Remove statements inside a function that assign a plain local name "
+            "to itself (`x = x`), since they have no effect. Class-body and "
+            "module-level `X = X` bind a new name from an enclosing one and are "
+            "left alone, as are attribute and subscript targets, which run "
+            "`__set__` and `__setitem__`."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "code-quality", "RSPEC-S1656"]
+
+    @property
+    def estimated_effort_per_occurrence(self) -> int:
+        return 3
+
+    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) or not _in_function_scope(self.cursor):
+                    return block
+                removed = _remove_self_assignments(
+                    block._statements, block.end, _space_after_block(self.cursor)
+                )
+                if removed is not None:
+                    return block.replace(_statements=removed[0], _end=removed[1])
+                return block
+
+        return Visitor()

openrewrite_migrate_python-0.14.0.dev20260902122728/src/openrewrite_migrate_python/migrate/datetime_utc.py

@@ -0,0 +1,274 @@
+"""
+Recipes for migrating deprecated datetime.utcnow() and datetime.utcfromtimestamp() calls.
+
+These methods are deprecated in Python 3.12+ because they return naive datetime objects
+that don't carry timezone information. The recommended replacements are:
+
+- datetime.utcnow() -> datetime.now(UTC)
+- datetime.utcfromtimestamp(ts) -> datetime.fromtimestamp(ts, UTC)
+
+The replacements are timezone-aware where the deprecated calls were naive, so values already
+stored or compared as naive UTC need migrating alongside the call sites.
+
+See: https://docs.python.org/3/library/datetime.html#datetime.datetime.utcnow
+"""
+
+from functools import lru_cache
+from typing import Any, Dict, Iterable, List, Optional, Tuple, cast
+
+from rewrite import Cursor, ExecutionContext, Preconditions, Recipe, TreeVisitor
+from rewrite.category import CategoryDescriptor
+from rewrite.decorators import categorize
+from rewrite.marketplace import Python
+from rewrite.python.add_import import AddImportOptions, maybe_add_import
+from rewrite.python.import_utils import get_alias_name, get_name_string, get_qualid_name
+from rewrite.python.preconditions import uses_import
+from rewrite.python.scope_utils import LocalBindings
+from rewrite.python.visitor import PythonVisitor
+from rewrite.python.template import Template, capture, raw, template
+from rewrite.python.tree import CompilationUnit, MultiImport, NamedArgument
+from rewrite.java.tree import (
+    Block, Empty, FieldAccess, Identifier, Import, J, MethodDeclaration, MethodInvocation,
+)
+
+# Define category path: Python > Migrate > Python 3.12
+_Python312 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.12"),
+]
+
+_sel = capture('sel')
+_ts = capture('ts')
+
+# Names `datetime` exports for UTC, each with the expression reaching it, in preference
+# order: `timezone` is the one Django code routinely binds to `django.utils.timezone`.
+_UTC_NAMES: Tuple[Tuple[str, str], ...] = (("UTC", "UTC"), ("timezone", "timezone.utc"))
+
+_DATETIME_CLASS = ("datetime", "datetime")
+_DATETIME_MODULE = (None, "datetime")
+
+
+@lru_cache(maxsize=None)
+def _now_template(utc: str) -> Template:
+    return template(f"{_sel}.now({raw(utc)})")
+
+
+@lru_cache(maxsize=None)
+def _fromtimestamp_template(utc: str) -> Template:
+    return template(f"{_sel}.fromtimestamp({_ts}, {raw(utc)})")
+
+
+def _import_bindings(statements: Iterable[J]) -> Dict[str, Tuple[Optional[str], str]]:
+    """Every name the imports among ``statements`` bind, mapped to the ``(from, name)`` pair it
+    was imported as -- ``(None, 'datetime')`` for ``import datetime``."""
+    bindings: Dict[str, Tuple[Optional[str], str]] = {}
+
+    def record(imp: Import, from_: Optional[str]) -> None:
+        name = get_qualid_name(imp.qualid)
+        bindings[get_alias_name(imp) or name.split('.')[0]] = (from_, name)
+
+    for stmt in statements:
+        if isinstance(stmt, MultiImport):
+            from_ = get_name_string(stmt.from_) if stmt.from_ is not None else None
+            for imp in stmt.names:
+                record(imp, from_)
+        elif isinstance(stmt, Import):
+            record(stmt, None)
+    return bindings
+
+
+def _enclosing_function_body(cursor: Optional[Cursor]) -> List[J]:
+    """The statements of the innermost function enclosing ``cursor``, empty outside one."""
+    while cursor is not None:
+        value = cursor.value
+        if isinstance(value, MethodDeclaration):
+            return list(value.body.statements) if isinstance(value.body, Block) else []
+        cursor = cursor.parent
+    return []
+
+
+class _DatetimeUtcVisitor(PythonVisitor[ExecutionContext]):
+    """Rewrites a naive UTC constructor to its aware counterpart, spelling UTC the way the
+    file's own ``datetime`` imports allow. Those imports also identify the receiver, which a
+    parse that attributes no types still supplies.
+    """
+
+    _target = ""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._bindings: Dict[str, Tuple[Optional[str], str]] = {}
+        self._locals = LocalBindings()
+
+    def visit_compilation_unit(self, cu: CompilationUnit, p: ExecutionContext) -> J:
+        self._bindings = _import_bindings(cu.statements)
+        self._locals = LocalBindings()
+        return super().visit_compilation_unit(cu, p)
+
+    def targets_datetime(self, method: MethodInvocation) -> bool:
+        if not isinstance(method.name, Identifier) or method.name.simple_name != self._target:
+            return False
+        select = method.select
+        if isinstance(select, Identifier):
+            return self._resolves(select.simple_name, _DATETIME_CLASS)
+        if isinstance(select, FieldAccess) and select.name.simple_name == "datetime":
+            return self._resolves(get_name_string(select.target), _DATETIME_MODULE)
+        return False
+
+    def _resolves(self, name: str, binding: Tuple[Optional[str], str]) -> bool:
+        if not self._locals.is_bound(self.cursor, name):
+            return self._bindings.get(name) == binding
+        # A deferred `from datetime import datetime` shadows the module-level name with the
+        # same class, so the receiver is still `datetime.datetime`.
+        return _import_bindings(_enclosing_function_body(self.cursor)).get(name) == binding
+
+    def utc_reference(self, select: Optional[J]) -> Optional[str]:
+        """An expression evaluating to ``datetime.UTC`` at ``select``'s call site, registering an
+        import if one is needed, or None when no name is free to bind it to."""
+        if isinstance(select, FieldAccess):
+            # `import datetime` puts UTC on the same module the class was reached through.
+            return f"{get_name_string(select.target)}.UTC"
+
+        # The expression is emitted at the call site, where an enclosing scope's binding of
+        # the name wins over the module-level import it would otherwise reach.
+        free = [(n, e) for n, e in _UTC_NAMES if not self._locals.is_bound(self.cursor, n)]
+
+        for name, expression in free:
+            if self._bindings.get(name) == ("datetime", name):
+                return expression
+
+        for name, expression in free:
+            if name not in self._bindings:
+                maybe_add_import(
+                    self,
+                    AddImportOptions(module="datetime", name=name, only_if_referenced=False),
+                )
+                return expression
+
+        return None
+
+
+@categorize(_Python312)
+class ReplaceDatetimeUtcNow(Recipe):
+    """
+    Replace `datetime.utcnow()` with `datetime.now(UTC)`.
+
+    The `datetime.utcnow()` method is deprecated in Python 3.12 because it returns
+    a naive datetime object that doesn't carry timezone information. This can lead
+    to subtle bugs when comparing or converting between timezones.
+
+    Example:
+        Before:
+            from datetime import datetime
+            now = datetime.utcnow()
+
+        After:
+            from datetime import datetime, UTC
+            now = datetime.now(UTC)
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplaceDatetimeUtcNow"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `datetime.utcnow()` with `datetime.now(UTC)`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "The `datetime.utcnow()` method is deprecated in Python 3.12. "
+            "Replace it with `datetime.now(UTC)`, importing `UTC` from `datetime` where the "
+            "name is not already in scope. The result is timezone-aware where `utcnow()` was "
+            "naive, so stored or compared values may need migrating alongside the call sites."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.12", "datetime"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(_DatetimeUtcVisitor):
+            _target = "utcnow"
+
+            def visit_method_invocation(
+                self, method: MethodInvocation, p: ExecutionContext
+            ) -> J:
+                method = cast(MethodInvocation, super().visit_method_invocation(method, p))
+                if not self.targets_datetime(method):
+                    return method
+                utc = self.utc_reference(method.select)
+                if utc is None:
+                    return method
+                replaced = _now_template(utc).apply(self.cursor, values={'sel': method.select})
+                return replaced if replaced is not None else method
+
+        return Preconditions.check(uses_import("datetime"), Visitor())
+
+
+@categorize(_Python312)
+class ReplaceDatetimeUtcFromTimestamp(Recipe):
+    """
+    Replace `datetime.utcfromtimestamp(ts)` with `datetime.fromtimestamp(ts, UTC)`.
+
+    The `datetime.utcfromtimestamp()` method is deprecated in Python 3.12 because it
+    returns a naive datetime object.
+
+    Example:
+        Before:
+            from datetime import datetime
+            dt = datetime.utcfromtimestamp(1234567890)
+
+        After:
+            from datetime import datetime, UTC
+            dt = datetime.fromtimestamp(1234567890, UTC)
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplaceDatetimeUtcFromTimestamp"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `datetime.utcfromtimestamp()` with `datetime.fromtimestamp(ts, UTC)`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "The `datetime.utcfromtimestamp()` method is deprecated in Python 3.12. "
+            "Replace it with `datetime.fromtimestamp(ts, UTC)`, importing `UTC` from "
+            "`datetime` where the name is not already in scope. The result is timezone-aware "
+            "where `utcfromtimestamp()` was naive, so stored or compared values may need "
+            "migrating alongside the call sites."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.12", "datetime"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(_DatetimeUtcVisitor):
+            _target = "utcfromtimestamp"
+
+            def visit_method_invocation(
+                self, method: MethodInvocation, p: ExecutionContext
+            ) -> J:
+                method = cast(MethodInvocation, super().visit_method_invocation(method, p))
+                if not self.targets_datetime(method):
+                    return method
+                # The tz the template appends is positional, so it cannot follow a keyword one.
+                if len(method.arguments) != 1 or isinstance(
+                    method.arguments[0], (Empty, NamedArgument)
+                ):
+                    return method
+                utc = self.utc_reference(method.select)
+                if utc is None:
+                    return method
+                replaced = _fromtimestamp_template(utc).apply(
+                    self.cursor, values={'sel': method.select, 'ts': method.arguments[0]}
+                )
+                return replaced if replaced is not None else method
+
+        return Preconditions.check(uses_import("datetime"), Visitor())

{openrewrite_migrate_python-0.14.0.dev20260902102558 → openrewrite_migrate_python-0.14.0.dev20260902122728}/src/openrewrite_migrate_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrewrite-migrate-python
-Version: 0.14.0.dev20260902102558
+Version: 0.14.0.dev20260902122728
 Summary: OpenRewrite recipes for migrating Python codebases to newer Python versions.
 Author-email: "Moderne Inc." <support@moderne.io>
 License: Moderne Proprietary