openrewrite-migrate-python 0.1.0__py3-none-any.whl

openrewrite_migrate_python/migrate/typing_callable.py

@@ -0,0 +1,153 @@
+"""
+Recipe for migrating typing.Callable to collections.abc.Callable.
+
+PEP 585 (Python 3.9+) deprecated typing.Callable in favor of
+collections.abc.Callable:
+
+- typing.Callable[[int], str] -> collections.abc.Callable[[int], str]
+
+See: https://peps.python.org/pep-0585/
+"""
+
+from typing import Any, Optional, Set
+
+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, SearchResult
+from rewrite.utils import random_id
+from rewrite.python.visitor import PythonVisitor
+from rewrite.python.tree import MultiImport
+from rewrite.java.tree import FieldAccess, Identifier, Import
+
+# Define category path
+_Python39 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.9"),
+]
+
+
+def _mark_deprecated(tree: Any, message: str, detail: Optional[str] = None) -> Any:
+    """Add a SearchResult marker for a deprecation warning."""
+    full_message = f"{message}: {detail}" if detail else message
+    search_marker = SearchResult(random_id(), full_message)
+    current_markers = tree.markers
+    new_markers_list = list(current_markers.markers) + [search_marker]
+    new_markers = Markers(current_markers.id, new_markers_list)
+    return tree.replace(_markers=new_markers)
+
+
+@categorize(_Python39)
+class ReplaceTypingCallableWithCollectionsAbcCallable(Recipe):
+    """
+    Find and migrate `typing.Callable` to `collections.abc.Callable`.
+
+    PEP 585 deprecated `typing.Callable` in Python 3.9. Use
+    `collections.abc.Callable` instead for type annotations.
+
+    Example:
+        Before:
+            from typing import Callable
+            handler: Callable[[int], str] = lambda x: str(x)
+
+        After:
+            from collections.abc import Callable
+            handler: Callable[[int], str] = lambda x: str(x)
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplaceTypingCallableWithCollectionsAbcCallable"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `typing.Callable` with `collections.abc.Callable`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "PEP 585 deprecated `typing.Callable` in Python 3.9. "
+            "Replace with `collections.abc.Callable` for type annotations."
+        )
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def __init__(self):
+                super().__init__()
+                self._has_typing_callable_import = False
+                self._has_typing_star_import = False
+
+            def visit_multi_import(self, multi_import: MultiImport, p: ExecutionContext):
+                """Track 'from typing import Callable' imports."""
+                from_ = multi_import.from_
+                if isinstance(from_, Identifier) and from_.simple_name == "typing":
+                    for imp in multi_import.names:
+                        qualid = imp.qualid
+                        if isinstance(qualid, FieldAccess):
+                            name = qualid.name
+                            if isinstance(name, Identifier) and name.simple_name == "Callable":
+                                self._has_typing_callable_import = True
+                        elif isinstance(qualid, Identifier) and qualid.simple_name == "Callable":
+                            self._has_typing_callable_import = True
+                return super().visit_multi_import(multi_import, p)
+
+            def visit_import(self, import_node: Import, p: ExecutionContext):
+                """Track 'import typing' imports."""
+                qualid = import_node.qualid
+                if isinstance(qualid, Identifier) and qualid.simple_name == "typing":
+                    self._has_typing_star_import = True
+                elif isinstance(qualid, FieldAccess):
+                    name = qualid.name
+                    if isinstance(name, Identifier) and name.simple_name == "typing":
+                        self._has_typing_star_import = True
+                return super().visit_import(import_node, p)
+
+            def visit_identifier(
+                self, identifier: Identifier, p: ExecutionContext
+            ) -> Optional[Identifier]:
+                identifier = super().visit_identifier(identifier, p)
+
+                if identifier.simple_name == "Callable" and self._has_typing_callable_import:
+                    # Skip identifiers that are part of import statements
+                    if not self._is_in_import(identifier):
+                        return _mark_deprecated(
+                            identifier,
+                            "typing.Callable is deprecated",
+                            "Replace with collections.abc.Callable (PEP 585)"
+                        )
+
+                return identifier
+
+            def visit_field_access(self, field_access: FieldAccess, p: ExecutionContext):
+                """Handle typing.Callable qualified access."""
+                field_access = super().visit_field_access(field_access, p)
+
+                if self._has_typing_star_import:
+                    name = field_access.name
+                    target = field_access.target
+                    if (isinstance(name, Identifier) and name.simple_name == "Callable" and
+                            isinstance(target, Identifier) and target.simple_name == "typing"):
+                        marked_name = _mark_deprecated(
+                            name,
+                            "typing.Callable is deprecated",
+                            "Replace with collections.abc.Callable (PEP 585)"
+                        )
+                        return field_access.replace(
+                            _name=field_access.padding.name.replace(_element=marked_name)
+                        )
+
+                return field_access
+
+            def _is_in_import(self, identifier: Identifier) -> bool:
+                """Check if the identifier is inside an import statement."""
+                cursor = self.cursor
+                while cursor is not None:
+                    value = cursor.value
+                    if isinstance(value, (Import, MultiImport)):
+                        return True
+                    cursor = cursor.parent
+                return False
+
+        return Visitor()

openrewrite_migrate_python/migrate/typing_deprecations.py

@@ -0,0 +1,337 @@
+"""
+Recipes for migrating deprecated typing module aliases to built-in generics.
+
+PEP 585 (Python 3.9+) deprecated many typing module aliases in favor of
+using built-in types directly as 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 is deprecated (alias for str since Python 3.11).
+
+See: https://peps.python.org/pep-0585/
+"""
+
+from typing import Any, Optional, Dict
+
+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, SearchResult
+from rewrite.utils import random_id
+from rewrite.python.visitor import PythonVisitor
+from rewrite.java.tree import Identifier
+
+# 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 _mark_deprecated(tree: Any, message: str, detail: Optional[str] = None) -> Any:
+    """Add a SearchResult marker for a deprecation warning."""
+    full_message = f"{message}: {detail}" if detail else message
+    search_marker = SearchResult(random_id(), full_message)
+    current_markers = tree.markers
+    new_markers_list = list(current_markers.markers) + [search_marker]
+    new_markers = Markers(current_markers.id, new_markers_list)
+    return tree.replace(_markers=new_markers)
+
+
+# PEP 585 deprecated typing aliases -> built-in replacements
+PEP585_DEPRECATIONS: Dict[str, str] = {
+    "List": "list",
+    "Dict": "dict",
+    "Set": "set",
+    "FrozenSet": "frozenset",
+    "Tuple": "tuple",
+    "Type": "type",
+}
+
+
+@categorize(_Python39)
+class ReplaceTypingListWithList(Recipe):
+    """
+    Find and migrate `typing.List` to built-in `list`.
+
+    PEP 585 deprecated `typing.List` in Python 3.9. The built-in `list` type
+    can now be used directly as a generic type.
+
+    Example:
+        Before:
+            from typing import List
+            items: List[str] = []
+
+        After:
+            items: list[str] = []
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplaceTypingListWithList"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `typing.List` with `list`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "PEP 585 deprecated `typing.List` in Python 3.9. "
+            "Replace with the built-in `list` type for generic annotations."
+        )
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_identifier(
+                self, identifier: Identifier, p: ExecutionContext
+            ) -> Optional[Identifier]:
+                identifier = super().visit_identifier(identifier, p)
+
+                if identifier.simple_name == "List":
+                    # Check if this is from typing module via type attribution
+                    if identifier.field_type:
+                        fqn = str(getattr(identifier.field_type, '_fully_qualified_name', ''))
+                        if 'typing' in fqn:
+                            return _mark_deprecated(
+                                identifier,
+                                "typing.List is deprecated",
+                                "Replace with built-in list (PEP 585)"
+                            )
+
+                return identifier
+
+        return Visitor()
+
+
+@categorize(_Python39)
+class ReplaceTypingDictWithDict(Recipe):
+    """
+    Find and migrate `typing.Dict` to built-in `dict`.
+
+    PEP 585 deprecated `typing.Dict` in Python 3.9. The built-in `dict` type
+    can now be used directly as a generic type.
+
+    Example:
+        Before:
+            from typing import Dict
+            mapping: Dict[str, int] = {}
+
+        After:
+            mapping: dict[str, int] = {}
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplaceTypingDictWithDict"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `typing.Dict` with `dict`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "PEP 585 deprecated `typing.Dict` in Python 3.9. "
+            "Replace with the built-in `dict` type for generic annotations."
+        )
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_identifier(
+                self, identifier: Identifier, p: ExecutionContext
+            ) -> Optional[Identifier]:
+                identifier = super().visit_identifier(identifier, p)
+
+                if identifier.simple_name == "Dict":
+                    if identifier.field_type:
+                        fqn = str(getattr(identifier.field_type, '_fully_qualified_name', ''))
+                        if 'typing' in fqn:
+                            return _mark_deprecated(
+                                identifier,
+                                "typing.Dict is deprecated",
+                                "Replace with built-in dict (PEP 585)"
+                            )
+
+                return identifier
+
+        return Visitor()
+
+
+@categorize(_Python39)
+class ReplaceTypingSetWithSet(Recipe):
+    """
+    Find and migrate `typing.Set` to built-in `set`.
+
+    PEP 585 deprecated `typing.Set` in Python 3.9. The built-in `set` type
+    can now be used directly as a generic type.
+
+    Example:
+        Before:
+            from typing import Set
+            items: Set[int] = set()
+
+        After:
+            items: set[int] = set()
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplaceTypingSetWithSet"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `typing.Set` with `set`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "PEP 585 deprecated `typing.Set` in Python 3.9. "
+            "Replace with the built-in `set` type for generic annotations."
+        )
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_identifier(
+                self, identifier: Identifier, p: ExecutionContext
+            ) -> Optional[Identifier]:
+                identifier = super().visit_identifier(identifier, p)
+
+                if identifier.simple_name == "Set":
+                    if identifier.field_type:
+                        fqn = str(getattr(identifier.field_type, '_fully_qualified_name', ''))
+                        if 'typing' in fqn:
+                            return _mark_deprecated(
+                                identifier,
+                                "typing.Set is deprecated",
+                                "Replace with built-in set (PEP 585)"
+                            )
+
+                return identifier
+
+        return Visitor()
+
+
+@categorize(_Python39)
+class ReplaceTypingTupleWithTuple(Recipe):
+    """
+    Find and migrate `typing.Tuple` to built-in `tuple`.
+
+    PEP 585 deprecated `typing.Tuple` in Python 3.9. The built-in `tuple` type
+    can now be used directly as a generic type.
+
+    Example:
+        Before:
+            from typing import Tuple
+            point: Tuple[int, int] = (0, 0)
+
+        After:
+            point: tuple[int, int] = (0, 0)
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplaceTypingTupleWithTuple"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `typing.Tuple` with `tuple`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "PEP 585 deprecated `typing.Tuple` in Python 3.9. "
+            "Replace with the built-in `tuple` type for generic annotations."
+        )
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_identifier(
+                self, identifier: Identifier, p: ExecutionContext
+            ) -> Optional[Identifier]:
+                identifier = super().visit_identifier(identifier, p)
+
+                if identifier.simple_name == "Tuple":
+                    if identifier.field_type:
+                        fqn = str(getattr(identifier.field_type, '_fully_qualified_name', ''))
+                        if 'typing' in fqn:
+                            return _mark_deprecated(
+                                identifier,
+                                "typing.Tuple is deprecated",
+                                "Replace with built-in tuple (PEP 585)"
+                            )
+
+                return identifier
+
+        return Visitor()
+
+
+@categorize(_Python311)
+class ReplaceTypingText(Recipe):
+    """
+    Find and 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"
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplaceTypingText"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `typing.Text` with `str`"
+
+    @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`."
+        )
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        from rewrite.python.tree import Import, MultiImport
+
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_identifier(
+                self, ident: Identifier, p: ExecutionContext
+            ) -> Optional[Identifier]:
+                ident = super().visit_identifier(ident, p)
+
+                if ident.simple_name != "Text":
+                    return ident
+
+                # Skip identifiers inside import statements
+                if (self.cursor.first_enclosing(MultiImport) is not None or
+                        self.cursor.first_enclosing(Import) is not None):
+                    return ident
+
+                # Type attribution correctly resolves typing.Text to str
+                # (since Text is just an alias), so we can't use field_type to
+                # confirm the import origin. Instead we rely on the name check
+                # and the import-context guard above.
+                return ident.replace(_simple_name="str")
+
+        return Visitor()