openrewrite-migrate-python 0.11.0.dev20260728173129__tar.gz → 0.12.0__tar.gz

{openrewrite_migrate_python-0.11.0.dev20260728173129 → openrewrite_migrate_python-0.12.0}/PKG-INFO

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

{openrewrite_migrate_python-0.11.0.dev20260728173129 → openrewrite_migrate_python-0.12.0}/src/openrewrite_migrate_python/migrate/__init__.py

@@ -100,10 +100,12 @@ from .threading_deprecations import (
 from .typing_callable import ReplaceTypingCallableWithCollectionsAbcCallable
 from .typing_deprecations import (
     ReplaceTypingDictWithDict,
+    ReplaceTypingFrozenSetWithFrozenset,
     ReplaceTypingListWithList,
     ReplaceTypingSetWithSet,
     ReplaceTypingText,
     ReplaceTypingTupleWithTuple,
+    ReplaceTypingTypeWithType,
 )
 from .typing_union_to_pipe import (
     ReplaceTypingOptionalWithUnion,
@@ -222,11 +224,13 @@ __all__ = [
     # Auto-fix: Typing
     "ReplaceTypingCallableWithCollectionsAbcCallable",
     "ReplaceTypingDictWithDict",
+    "ReplaceTypingFrozenSetWithFrozenset",
     "ReplaceTypingListWithList",
     "ReplaceTypingOptionalWithUnion",
     "ReplaceTypingSetWithSet",
     "ReplaceTypingText",
     "ReplaceTypingTupleWithTuple",
+    "ReplaceTypingTypeWithType",
     "ReplaceTypingUnionWithPipe",
     # Auto-fix: Unittest
     "ReplaceUnittestDeprecatedAliases",

openrewrite_migrate_python-0.12.0/src/openrewrite_migrate_python/migrate/_import_hygiene.py

@@ -0,0 +1,55 @@
+"""Internal cleanup recipe shared by composites built on `ChangeImport`.
+
+When every name of a ``from X import a, b`` statement is migrated away, the
+SDK's `ChangeImport` drops the emptied statement without transferring its
+prefix, which can leave a blank line at the very start of the file. This
+recipe trims it. It runs as the last step of a composite, after all import
+rewrites have been applied.
+"""
+
+from typing import Any
+
+from rewrite import ExecutionContext, Recipe, TreeVisitor
+from rewrite.java.support_types import JRightPadded
+from rewrite.java.tree import Import
+from rewrite.python.tree import CompilationUnit, MultiImport
+from rewrite.python.visitor import PythonVisitor
+
+
+class TrimLeadingBlankLines(Recipe):
+    """Remove blank lines that precede a file's first import statement."""
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.TrimLeadingBlankLines"
+
+    @property
+    def display_name(self) -> str:
+        return "Trim blank lines before a leading import"
+
+    @property
+    def description(self) -> str:
+        return "Remove blank lines that precede a file's first import statement."
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_compilation_unit(
+                self, cu: CompilationUnit, p: ExecutionContext
+            ) -> CompilationUnit:
+                padded_stmts = list(cu.padding.statements)
+                if not padded_stmts:
+                    return cu
+                first = padded_stmts[0]
+                stmt = first.element
+                if not isinstance(stmt, (Import, MultiImport)):
+                    return cu
+                prefix = stmt.prefix
+                if prefix.comments or not prefix.whitespace or not prefix.whitespace.startswith("\n"):
+                    return cu
+                new_prefix = prefix.replace(_whitespace=prefix.whitespace.lstrip("\n"))
+                padded_stmts[0] = JRightPadded(
+                    stmt.replace(prefix=new_prefix), first.after, first.markers
+                )
+                return cu.padding.replace(_statements=padded_stmts)
+
+        return Visitor()

openrewrite_migrate_python-0.12.0/src/openrewrite_migrate_python/migrate/_typing_imports.py

@@ -0,0 +1,48 @@
+"""Internal helpers for locating references to the typing module in a file."""
+
+from typing import Dict, Set, Tuple
+
+from rewrite.java.tree import Import
+from rewrite.python.import_utils import get_alias_name, get_name_string, get_qualid_name
+from rewrite.python.remove_import import RemoveImportOptions, maybe_remove_import
+from rewrite.python.tree import CompilationUnit, MultiImport
+from rewrite.python.visitor import PythonVisitor
+
+
+def scan_typing_imports(cu: CompilationUnit) -> Tuple[Dict[str, str], Set[str]]:
+    """Map how this file can reference typing members.
+
+    Returns:
+        A tuple of:
+        - exposed name -> typing member, for ``from typing import member [as alias]``
+        - the set of names bound to the typing module itself, for
+          ``import typing [as alias]``
+    """
+    members: Dict[str, str] = {}
+    module_refs: Set[str] = set()
+    for stmt in cu.statements:
+        if isinstance(stmt, MultiImport):
+            if stmt.from_ is not None:
+                if get_name_string(stmt.from_) == "typing":
+                    for imp in stmt.names:
+                        name = get_qualid_name(imp.qualid)
+                        members.setdefault(get_alias_name(imp) or name, name)
+            else:
+                for imp in stmt.names:
+                    if get_qualid_name(imp.qualid) == "typing":
+                        module_refs.add(get_alias_name(imp) or "typing")
+        elif isinstance(stmt, Import):
+            if get_qualid_name(stmt.qualid) == "typing":
+                module_refs.add(get_alias_name(stmt) or "typing")
+    return members, module_refs
+
+
+def maybe_remove_typing_module_import(visitor: PythonVisitor, module_refs: Set[str]) -> None:
+    """Schedule removal of `import typing` once it is no longer used.
+
+    RemoveImport's usage check counts `typing` identifiers, which an aliased
+    module import doesn't produce — removal is only scheduled when an
+    unaliased `import typing` exists.
+    """
+    if "typing" in module_refs:
+        maybe_remove_import(visitor, RemoveImportOptions(module="typing"))

openrewrite_migrate_python-0.12.0/src/openrewrite_migrate_python/migrate/collections_abc_migrations.py

@@ -0,0 +1,105 @@
+"""
+Recipes for migrating deprecated collections imports to collections.abc.
+
+The abstract base classes were moved from `collections` to `collections.abc`
+in Python 3.3 and the old import locations were removed in Python 3.10.
+
+See: https://docs.python.org/3/library/collections.abc.html
+"""
+
+from typing import List
+
+from rewrite import Recipe
+from rewrite.category import CategoryDescriptor
+from rewrite.decorators import categorize
+from rewrite.marketplace import Python
+from rewrite.python.recipes import ChangeImport
+
+# Define category path: Python > Migrate > Python 3.10
+_Python310 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.10"),
+]
+
+# All ABC aliases that `collections` re-exported until their removal in
+# Python 3.10 (`_collections_abc.__all__` as of Python 3.9).
+COLLECTIONS_ABC_CLASSES: tuple = (
+    "AsyncGenerator",
+    "AsyncIterable",
+    "AsyncIterator",
+    "Awaitable",
+    "ByteString",
+    "Callable",
+    "Collection",
+    "Container",
+    "Coroutine",
+    "Generator",
+    "Hashable",
+    "ItemsView",
+    "Iterable",
+    "Iterator",
+    "KeysView",
+    "Mapping",
+    "MappingView",
+    "MutableMapping",
+    "MutableSequence",
+    "MutableSet",
+    "Reversible",
+    "Sequence",
+    "Set",
+    "Sized",
+    "ValuesView",
+)
+
+
+@categorize(_Python310)
+class ReplaceCollectionsAbcImports(Recipe):
+    """
+    Replace deprecated `collections` imports with `collections.abc` imports.
+
+    The abstract base classes were moved from `collections` to `collections.abc`
+    in Python 3.3 and the old import locations were removed in Python 3.10.
+
+    Example:
+        Before:
+            from collections import Callable, Mapping
+
+        After:
+            from collections.abc import Callable, Mapping
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplaceCollectionsAbcImports"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `collections` ABC imports with `collections.abc`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Migrate deprecated abstract base class imports from `collections` to "
+            "`collections.abc`. These imports were deprecated in Python 3.3 and "
+            "removed in Python 3.10."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.10", "collections"]
+
+    def recipe_list(self) -> List[Recipe]:
+        from ._import_hygiene import TrimLeadingBlankLines
+
+        return [
+            *(
+                ChangeImport(
+                    old_module="collections",
+                    old_name=abc_class,
+                    new_module="collections.abc",
+                )
+                for abc_class in COLLECTIONS_ABC_CLASSES
+            ),
+            TrimLeadingBlankLines(),
+        ]

{openrewrite_migrate_python-0.11.0.dev20260728173129 → openrewrite_migrate_python-0.12.0}/src/openrewrite_migrate_python/migrate/future_imports.py

@@ -91,7 +91,9 @@ class RemoveFutureImports(Recipe):
     def description(self) -> str:
         return (
             "Remove `from __future__ import ...` statements for features that "
-            "are enabled by default in Python 3."
+            "are enabled by default in Python 3. The search-only `FindFutureImports` "
+            "recipe reports all `__future__` imports, including `annotations`, "
+            "which this recipe keeps."
         )
 
     @property

{openrewrite_migrate_python-0.11.0.dev20260728173129 → openrewrite_migrate_python-0.12.0}/src/openrewrite_migrate_python/migrate/typing_callable.py

@@ -15,7 +15,7 @@ from rewrite import Recipe
 from rewrite.category import CategoryDescriptor
 from rewrite.decorators import categorize
 from rewrite.marketplace import Python
-from rewrite.python.recipes import ChangeType
+from rewrite.python.recipes import ChangeImport
 
 # Define category path
 _Python39 = [
@@ -60,8 +60,9 @@ class ReplaceTypingCallableWithCollectionsAbcCallable(Recipe):
 
     def recipe_list(self) -> List[Recipe]:
         return [
-            ChangeType(
-                old_fully_qualified_type_name="typing.Callable",
-                new_fully_qualified_type_name="collections.abc.Callable",
+            ChangeImport(
+                old_module="typing",
+                old_name="Callable",
+                new_module="collections.abc",
             )
         ]

openrewrite_migrate_python-0.12.0/src/openrewrite_migrate_python/migrate/typing_deprecations.py

@@ -0,0 +1,360 @@
+"""
+Recipes for migrating deprecated typing module aliases to built-in types.
+
+PEP 585 (Python 3.9+) deprecated the typing aliases for built-in generics:
+
+- typing.List[X] -> list[X]
+- typing.Dict[K, V] -> dict[K, V]
+- typing.Set[X] -> set[X]
+- typing.FrozenSet[X] -> frozenset[X]
+- typing.Tuple[X, ...] -> tuple[X, ...]
+- typing.Type[X] -> type[X]
+
+Additionally, typing.Text (an alias for str, deprecated in Python 3.11) is
+migrated to str by the same mechanism.
+
+Aliases that moved to another stdlib module (typing.Iterable, typing.Deque,
+typing.Pattern, ...) are import moves rather than builtin renames; they are
+handled with `ChangeImport` in `upgrade_to_python39`.
+
+See: https://peps.python.org/pep-0585/
+"""
+
+import re
+from typing import Any, ClassVar, Optional, Set, cast
+
+from rewrite import ExecutionContext, Recipe, TreeVisitor
+from rewrite.category import CategoryDescriptor
+from rewrite.decorators import categorize
+from rewrite.marketplace import Python
+from rewrite.python.import_utils import get_alias_name, get_name_string, get_qualid_name
+from rewrite.python.remove_import import RemoveImportOptions, maybe_remove_import
+
+from ._typing_imports import maybe_remove_typing_module_import
+from rewrite.python.tree import CompilationUnit, MultiImport, NamedArgument
+from rewrite.python.visitor import PythonVisitor
+from rewrite.java.tree import (
+    FieldAccess,
+    Identifier,
+    Import,
+    J,
+    Literal,
+    MethodDeclaration,
+    VariableDeclarations,
+)
+
+# Define category paths
+_Python39 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.9"),
+]
+
+_Python311 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.11"),
+]
+
+
+def _make_builtin_alias_editor(old_name: str, new_name: str) -> "TreeVisitor[Any, ExecutionContext]":
+    """Create a visitor that renames a typing alias to its built-in equivalent.
+
+    Handles both reference forms and cleans up imports afterwards:
+
+    - ``from typing import <old_name> [as alias]`` plus bare (or aliased)
+      identifier references
+    - ``import typing [as alias]`` plus qualified ``typing.<old_name>``
+      attribute references
+
+    Import removal is delegated to the SDK's `RemoveImport`, which only
+    removes imports that are no longer referenced and preserves comments.
+    """
+
+    class BuiltinAliasVisitor(PythonVisitor[ExecutionContext]):
+        def __init__(self) -> None:
+            super().__init__()
+            # Name that refers to the alias in code: the import alias if
+            # present, else the typing name. None when there is no from-import.
+            self._bare_ref: Optional[str] = None
+            # Names that refer to the typing module ('typing' or import aliases).
+            self._module_refs: Set[str] = set()
+            self._keep_from_import: bool = False
+            self._rewrote_qualified: bool = False
+
+        def visit_compilation_unit(
+            self, cu: CompilationUnit, p: ExecutionContext
+        ) -> CompilationUnit:
+            self._bare_ref = None
+            self._module_refs = set()
+            self._rewrote_qualified = False
+
+            for stmt in cu.statements:
+                if isinstance(stmt, MultiImport):
+                    if stmt.from_ is not None:
+                        if get_name_string(stmt.from_) == "typing":
+                            for imp in stmt.names:
+                                if get_qualid_name(imp.qualid) == old_name and self._bare_ref is None:
+                                    self._bare_ref = get_alias_name(imp) or old_name
+                    else:
+                        for imp in stmt.names:
+                            if get_qualid_name(imp.qualid) == "typing":
+                                self._module_refs.add(get_alias_name(imp) or "typing")
+                elif isinstance(stmt, Import):
+                    if get_qualid_name(stmt.qualid) == "typing":
+                        self._module_refs.add(get_alias_name(stmt) or "typing")
+
+            if self._bare_ref is None and not self._module_refs:
+                return cu
+
+            # A reference inside a string annotation is a Literal, not an
+            # Identifier, so it is neither renamed nor seen by RemoveImport's
+            # usage check; keep the import so such references stay resolvable.
+            self._keep_from_import = self._bare_ref is not None and self._used_in_string_literal(
+                cu, self._bare_ref
+            )
+
+            result = cast(CompilationUnit, super().visit_compilation_unit(cu, p))
+
+            if self._bare_ref is not None and not self._keep_from_import:
+                maybe_remove_import(
+                    self, RemoveImportOptions(module="typing", name=old_name)
+                )
+            if self._rewrote_qualified:
+                maybe_remove_typing_module_import(self, self._module_refs)
+
+            return result
+
+        @staticmethod
+        def _used_in_string_literal(cu: CompilationUnit, name: str) -> bool:
+            pattern = re.compile(rf"\b{re.escape(name)}\b")
+            found = False
+
+            class LiteralScan(PythonVisitor[Any]):
+                def visit_literal(self, literal: Literal, p: Any) -> J:
+                    nonlocal found
+                    if not found and isinstance(literal.value, str) and pattern.search(literal.value):
+                        found = True
+                    return literal
+
+            LiteralScan().visit(cu, None)
+            return found
+
+        def visit_field_access(self, field_access: FieldAccess, p: ExecutionContext) -> J:
+            if (
+                isinstance(field_access.target, Identifier)
+                and field_access.target.simple_name in self._module_refs
+                and field_access.name.simple_name == old_name
+            ):
+                self._rewrote_qualified = True
+                return field_access.name.replace(_simple_name=new_name).replace(
+                    prefix=field_access.prefix
+                )
+            return super().visit_field_access(field_access, p)
+
+        def visit_identifier(self, ident: Identifier, p: ExecutionContext) -> J:
+            ident = cast(Identifier, super().visit_identifier(ident, p))
+            if self._bare_ref is None or ident.simple_name != self._bare_ref:
+                return ident
+
+            # Skip identifiers that are part of import statements
+            if (
+                self.cursor.first_enclosing(MultiImport) is not None
+                or self.cursor.first_enclosing(Import) is not None
+            ):
+                return ident
+
+            parent = self.cursor.parent_tree_cursor().value
+            # The attribute of a field access (`x.List`) belongs to `x`'s
+            # namespace, not to the typing import.
+            if isinstance(parent, FieldAccess) and parent.name.id == ident.id:
+                return ident
+            # A keyword-argument name (`f(List=...)`) names a parameter.
+            if isinstance(parent, NamedArgument) and parent.name.id == ident.id:
+                return ident
+            # A declaration target (`List = ...`, `def f(List): ...`) binds a
+            # new name rather than referencing the import.
+            if (
+                isinstance(parent, VariableDeclarations.NamedVariable)
+                and parent.name.id == ident.id
+            ):
+                return ident
+            # Inside function scopes, type attribution marks shadowed locals
+            # with a field type; module-level references never carry one.
+            if (
+                self.cursor.first_enclosing(MethodDeclaration) is not None
+                and ident.field_type is not None
+            ):
+                return ident
+
+            return ident.replace(_simple_name=new_name)
+
+    return BuiltinAliasVisitor()
+
+
+class _ReplaceTypingAliasRecipe(Recipe):
+    """Base for recipes that replace a typing alias with a built-in type."""
+
+    old_name: ClassVar[str]
+    new_name: ClassVar[str]
+
+    @property
+    def name(self) -> str:
+        return (
+            "org.openrewrite.python.migrate."
+            f"ReplaceTyping{self.old_name}With{self.new_name.capitalize()}"
+        )
+
+    @property
+    def display_name(self) -> str:
+        return f"Replace `typing.{self.old_name}` with `{self.new_name}`"
+
+    @property
+    def description(self) -> str:
+        return (
+            f"PEP 585 deprecated `typing.{self.old_name}` in Python 3.9. "
+            f"Replace with the built-in `{self.new_name}` type for generic annotations."
+        )
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        return _make_builtin_alias_editor(self.old_name, self.new_name)
+
+
+@categorize(_Python39)
+class ReplaceTypingListWithList(_ReplaceTypingAliasRecipe):
+    """
+    Migrate `typing.List` to built-in `list`.
+
+    Example:
+        Before:
+            from typing import List
+            items: List[str] = []
+
+        After:
+            items: list[str] = []
+    """
+
+    old_name = "List"
+    new_name = "list"
+
+
+@categorize(_Python39)
+class ReplaceTypingDictWithDict(_ReplaceTypingAliasRecipe):
+    """
+    Migrate `typing.Dict` to built-in `dict`.
+
+    Example:
+        Before:
+            from typing import Dict
+            mapping: Dict[str, int] = {}
+
+        After:
+            mapping: dict[str, int] = {}
+    """
+
+    old_name = "Dict"
+    new_name = "dict"
+
+
+@categorize(_Python39)
+class ReplaceTypingSetWithSet(_ReplaceTypingAliasRecipe):
+    """
+    Migrate `typing.Set` to built-in `set`.
+
+    Example:
+        Before:
+            from typing import Set
+            items: Set[int] = set()
+
+        After:
+            items: set[int] = set()
+    """
+
+    old_name = "Set"
+    new_name = "set"
+
+
+@categorize(_Python39)
+class ReplaceTypingFrozenSetWithFrozenset(_ReplaceTypingAliasRecipe):
+    """
+    Migrate `typing.FrozenSet` to built-in `frozenset`.
+
+    Example:
+        Before:
+            from typing import FrozenSet
+            items: FrozenSet[int] = frozenset()
+
+        After:
+            items: frozenset[int] = frozenset()
+    """
+
+    old_name = "FrozenSet"
+    new_name = "frozenset"
+
+
+@categorize(_Python39)
+class ReplaceTypingTupleWithTuple(_ReplaceTypingAliasRecipe):
+    """
+    Migrate `typing.Tuple` to built-in `tuple`.
+
+    Example:
+        Before:
+            from typing import Tuple
+            point: Tuple[int, int] = (0, 0)
+
+        After:
+            point: tuple[int, int] = (0, 0)
+    """
+
+    old_name = "Tuple"
+    new_name = "tuple"
+
+
+@categorize(_Python39)
+class ReplaceTypingTypeWithType(_ReplaceTypingAliasRecipe):
+    """
+    Migrate `typing.Type` to built-in `type`.
+
+    Example:
+        Before:
+            from typing import Type
+            cls: Type[int] = int
+
+        After:
+            cls: type[int] = int
+    """
+
+    old_name = "Type"
+    new_name = "type"
+
+
+@categorize(_Python311)
+class ReplaceTypingText(_ReplaceTypingAliasRecipe):
+    """
+    Migrate `typing.Text` to `str`.
+
+    `typing.Text` was an alias for `str` provided for Python 2/3 compatibility.
+    It is deprecated as of Python 3.11 since Python 2 is no longer supported.
+
+    Example:
+        Before:
+            from typing import Text
+            name: Text = "hello"
+
+        After:
+            name: str = "hello"
+    """
+
+    old_name = "Text"
+    new_name = "str"
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplaceTypingText"
+
+    @property
+    def description(self) -> str:
+        return (
+            "`typing.Text` is deprecated as of Python 3.11. "
+            "It was an alias for `str` for Python 2/3 compatibility. Replace with `str`."
+        )