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

openrewrite_migrate_python/migrate/pipes_migrations.py

@@ -0,0 +1,130 @@
+"""
+Recipes for migrating from the deprecated pipes module.
+
+The pipes module was deprecated in Python 3.11 (PEP 594) and removed
+in Python 3.13.
+
+Replacements:
+- Use the `subprocess` module with `shlex.quote()` for shell escaping
+- Use `shlex.join()` (Python 3.8+) to build command lines
+
+See: https://peps.python.org/pep-0594/
+"""
+
+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, SearchResult
+from rewrite.utils import random_id
+from rewrite.python.visitor import PythonVisitor
+from rewrite.python.tree import MultiImport, Import
+from rewrite.java.tree import Identifier, FieldAccess
+
+# Define category path: Python > Migrate > Python 3.13
+_Python313 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.13"),
+]
+
+
+def _mark_deprecated(tree: Any, message: str) -> Any:
+    """Add a SearchResult marker for a deprecation warning."""
+    search_marker = SearchResult(random_id(), 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)
+
+
+def _get_import_name(import_node: Any) -> Optional[str]:
+    """Extract the module name from an import node's qualid."""
+    qualid = import_node.qualid
+    if isinstance(qualid, FieldAccess):
+        return qualid.name.simple_name
+    if isinstance(qualid, Identifier):
+        return qualid.simple_name
+    return None
+
+
+@categorize(_Python313)
+class FindPipesModule(Recipe):
+    """
+    Find imports of the deprecated `pipes` module.
+
+    The `pipes` module was deprecated in Python 3.11 and removed in
+    Python 3.13 as part of PEP 594 ("Removing dead batteries").
+
+    Alternatives:
+    - Use `subprocess` module for process pipelines
+    - Use `shlex.quote()` for shell escaping
+    - Use `shlex.join()` (Python 3.8+) to build command lines
+
+    See: https://peps.python.org/pep-0594/
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.FindPipesModule"
+
+    @property
+    def display_name(self) -> str:
+        return "Find deprecated `pipes` module usage"
+
+    @property
+    def description(self) -> str:
+        return (
+            "The `pipes` module was deprecated in Python 3.11 and removed in "
+            "Python 3.13. Use subprocess with shlex.quote() for shell escaping."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.13", "PEP 594"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_multi_import(
+                self, multi: MultiImport, p: ExecutionContext
+            ) -> Optional[MultiImport]:
+                multi = super().visit_multi_import(multi, p)
+
+                from_part = multi.from_
+                if from_part is not None:
+                    if isinstance(from_part, Identifier) and from_part.simple_name == "pipes":
+                        return _mark_deprecated(
+                            multi,
+                            "The `pipes` module was removed in Python 3.13. "
+                            "Use subprocess with shlex.quote() instead."
+                        )
+                else:
+                    for import_node in multi.names:
+                        name = _get_import_name(import_node)
+                        if name == "pipes":
+                            return _mark_deprecated(
+                                multi,
+                                "The `pipes` module was removed in Python 3.13. "
+                                "Use subprocess with shlex.quote() instead."
+                            )
+
+                return multi
+
+            def visit_import(
+                self, import_stmt: Import, p: ExecutionContext
+            ) -> Optional[Import]:
+                import_stmt = super().visit_import(import_stmt, p)
+                if self.cursor.first_enclosing(MultiImport) is not None:
+                    return import_stmt
+                name = _get_import_name(import_stmt)
+                if name == "pipes":
+                    return _mark_deprecated(
+                        import_stmt,
+                        "The `pipes` module was removed in Python 3.13. "
+                        "Use subprocess with shlex.quote() instead."
+                    )
+                return import_stmt
+
+        return Visitor()

openrewrite_migrate_python/migrate/pkgutil_deprecations.py

@@ -0,0 +1,180 @@
+"""
+Recipes for migrating deprecated pkgutil module functions.
+
+Several pkgutil functions were deprecated in Python 3.12:
+
+- pkgutil.find_loader() -> importlib.util.find_spec()
+- pkgutil.get_loader() -> importlib.util.find_spec()
+
+See: https://docs.python.org/3/library/pkgutil.html
+"""
+
+from typing import Any, 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, SearchResult
+from rewrite.python.visitor import PythonVisitor
+from rewrite.java.tree import Identifier, MethodInvocation
+from rewrite.utils import random_id
+
+# Define category path: Python > Migrate > Python 3.12
+_Python312 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.12"),
+]
+
+
+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)
+
+
+def _is_pkgutil_method(method: MethodInvocation, method_name: str) -> bool:
+    """
+    Check if this is a pkgutil.method_name() call.
+
+    Uses multiple strategies to identify the method:
+    1. Check method name matches
+    2. Check type attribution if available (FQN contains 'pkgutil')
+    3. Check simple name on select is 'pkgutil'
+    """
+    # Check method name first
+    if not isinstance(method.name, Identifier):
+        return False
+    if method.name.simple_name != method_name:
+        return False
+
+    # Check if type info confirms this is a pkgutil method
+    if method.method_type and method.method_type.declaring_type:
+        dt = method.method_type.declaring_type
+        if hasattr(dt, '_fully_qualified_name'):
+            fqn = str(dt._fully_qualified_name)
+            if 'pkgutil' in fqn:
+                return True
+
+    # Fallback: Check simple name on select
+    select = method.select
+    if select is None:
+        return False
+    if isinstance(select, Identifier) and select.simple_name == "pkgutil":
+        return True
+
+    return False
+
+
+@categorize(_Python312)
+class ReplacePkgutilFindLoader(Recipe):
+    """
+    Find and migrate `pkgutil.find_loader()` calls to `importlib.util.find_spec()`.
+
+    The `pkgutil.find_loader()` function was deprecated in Python 3.12.
+    The recommended replacement is `importlib.util.find_spec()`.
+
+    Note: The return types differ - `find_loader()` returns a loader while
+    `find_spec()` returns a ModuleSpec. Code may need additional changes.
+
+    Example:
+        Before:
+            import pkgutil
+            loader = pkgutil.find_loader('mymodule')
+
+        After:
+            import importlib.util
+            spec = importlib.util.find_spec('mymodule')
+            loader = spec.loader if spec else None
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplacePkgutilFindLoader"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `pkgutil.find_loader()` with `importlib.util.find_spec()`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "The `pkgutil.find_loader()` function was deprecated in Python 3.12. "
+            "Replace with `importlib.util.find_spec()`. Note: returns ModuleSpec, use .loader for loader."
+        )
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_method_invocation(
+                self, method: MethodInvocation, p: ExecutionContext
+            ) -> Optional[MethodInvocation]:
+                method = super().visit_method_invocation(method, p)
+
+                if _is_pkgutil_method(method, "find_loader"):
+                    return _mark_deprecated(
+                        method,
+                        "pkgutil.find_loader() is deprecated",
+                        "Replace with importlib.util.find_spec() (Python 3.12+)"
+                    )
+
+                return method
+
+        return Visitor()
+
+
+@categorize(_Python312)
+class ReplacePkgutilGetLoader(Recipe):
+    """
+    Find and migrate `pkgutil.get_loader()` calls to `importlib.util.find_spec()`.
+
+    The `pkgutil.get_loader()` function was deprecated in Python 3.12.
+    The recommended replacement is `importlib.util.find_spec()`.
+
+    Example:
+        Before:
+            import pkgutil
+            loader = pkgutil.get_loader('mymodule')
+
+        After:
+            import importlib.util
+            spec = importlib.util.find_spec('mymodule')
+            loader = spec.loader if spec else None
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplacePkgutilGetLoader"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `pkgutil.get_loader()` with `importlib.util.find_spec()`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "The `pkgutil.get_loader()` function was deprecated in Python 3.12. "
+            "Replace with `importlib.util.find_spec()`. Note: returns ModuleSpec, use .loader for loader."
+        )
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_method_invocation(
+                self, method: MethodInvocation, p: ExecutionContext
+            ) -> Optional[MethodInvocation]:
+                method = super().visit_method_invocation(method, p)
+
+                if _is_pkgutil_method(method, "get_loader"):
+                    return _mark_deprecated(
+                        method,
+                        "pkgutil.get_loader() is deprecated",
+                        "Replace with importlib.util.find_spec() (Python 3.12+)"
+                    )
+
+                return method
+
+        return Visitor()

openrewrite_migrate_python/migrate/platform_deprecations.py

@@ -0,0 +1,99 @@
+"""
+Recipes for migrating deprecated platform module functions.
+
+The following function was deprecated in Python 3.3 and removed in Python 3.8:
+- platform.popen() -> os.popen() or subprocess
+
+See: https://docs.python.org/3/whatsnew/3.8.html#api-and-feature-removals
+"""
+
+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, SearchResult
+from rewrite.utils import random_id
+from rewrite.python.visitor import PythonVisitor
+from rewrite.java.tree import Identifier, MethodInvocation
+
+# Define category path: Python > Migrate > Python 3.8
+_Python38 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.8"),
+]
+
+
+def _mark_deprecated(tree: Any, message: str) -> Any:
+    """Add a SearchResult marker for a deprecation warning."""
+    search_marker = SearchResult(random_id(), 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(_Python38)
+class FindPlatformPopen(Recipe):
+    """
+    Find usages of removed `platform.popen()`.
+
+    `platform.popen()` was deprecated in Python 3.3 and removed in Python 3.8.
+    Use `os.popen()` or `subprocess.run()` instead.
+
+    Example:
+        Before:
+            import platform
+            output = platform.popen('ls').read()
+
+        After:
+            import subprocess
+            output = subprocess.run(['ls'], capture_output=True, text=True).stdout
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.FindPlatformPopen"
+
+    @property
+    def display_name(self) -> str:
+        return "Find removed `platform.popen()` usage"
+
+    @property
+    def description(self) -> str:
+        return (
+            "`platform.popen()` was removed in Python 3.8. "
+            "Use `os.popen()` or `subprocess.run()` instead."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.8", "platform"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_method_invocation(
+                self, method: MethodInvocation, p: ExecutionContext
+            ) -> Optional[MethodInvocation]:
+                method = super().visit_method_invocation(method, p)
+
+                if not isinstance(method.name, Identifier):
+                    return method
+                if method.name.simple_name != "popen":
+                    return method
+
+                select = method.select
+                if not isinstance(select, Identifier):
+                    return method
+                if select.simple_name != "platform":
+                    return method
+
+                return _mark_deprecated(
+                    method,
+                    "platform.popen() was removed in Python 3.8. "
+                    "Use os.popen() or subprocess.run() instead."
+                )
+
+        return Visitor()

openrewrite_migrate_python/migrate/re_deprecations.py

@@ -0,0 +1,122 @@
+"""
+Recipe for finding deprecated re.template() and re.TEMPLATE usage.
+
+re.template() and re.TEMPLATE were deprecated in Python 3.11 and
+removed in Python 3.13.
+
+See: https://docs.python.org/3/whatsnew/3.11.html#deprecated
+"""
+
+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, SearchResult
+from rewrite.utils import random_id
+from rewrite.python.visitor import PythonVisitor
+from rewrite.java.tree import FieldAccess, Identifier, MethodInvocation
+
+# Define category path: Python > Migrate > Python 3.11
+_Python311 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.11"),
+]
+
+
+def _mark_deprecated(tree: Any, message: str) -> Any:
+    """Add a SearchResult marker for a deprecation warning."""
+    search_marker = SearchResult(random_id(), 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(_Python311)
+class FindReTemplate(Recipe):
+    """
+    Find usages of deprecated `re.template()` and `re.TEMPLATE`.
+
+    `re.template()` and `re.TEMPLATE` (aka `re.T`) were deprecated in
+    Python 3.11 and removed in Python 3.13. The template flag made
+    patterns match differently but was rarely useful.
+
+    Example:
+        Before:
+            import re
+            pattern = re.template(r'\\d+')
+            flags = re.TEMPLATE
+
+        After:
+            import re
+            pattern = re.compile(r'\\d+')
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.FindReTemplate"
+
+    @property
+    def display_name(self) -> str:
+        return "Find deprecated `re.template()` / `re.TEMPLATE` usage"
+
+    @property
+    def description(self) -> str:
+        return (
+            "`re.template()` and `re.TEMPLATE` were deprecated in Python 3.11 "
+            "and removed in 3.13."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.11", "re"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_method_invocation(
+                self, method: MethodInvocation, p: ExecutionContext
+            ) -> Optional[MethodInvocation]:
+                method = super().visit_method_invocation(method, p)
+
+                if not isinstance(method.name, Identifier):
+                    return method
+                if method.name.simple_name != "template":
+                    return method
+
+                select = method.select
+                if not isinstance(select, Identifier):
+                    return method
+                if select.simple_name != "re":
+                    return method
+
+                return _mark_deprecated(
+                    method,
+                    "re.template() was deprecated in Python 3.11 and removed in 3.13."
+                )
+
+            def visit_field_access(
+                self, field_access: FieldAccess, p: ExecutionContext
+            ) -> Optional[FieldAccess]:
+                field_access = super().visit_field_access(field_access, p)
+
+                if not isinstance(field_access.name, Identifier):
+                    return field_access
+                if field_access.name.simple_name not in ("TEMPLATE", "T"):
+                    return field_access
+
+                target = field_access.target
+                if not isinstance(target, Identifier):
+                    return field_access
+                if target.simple_name != "re":
+                    return field_access
+
+                return _mark_deprecated(
+                    field_access,
+                    f"re.{field_access.name.simple_name} was deprecated in Python 3.11 "
+                    "and removed in 3.13."
+                )
+
+        return Visitor()

openrewrite_migrate_python/migrate/removed_modules_312.py

@@ -0,0 +1,139 @@
+"""
+Recipe for finding imports of modules removed in Python 3.12.
+
+The following modules were removed in Python 3.12:
+- asynchat (use asyncio)
+- asyncore (use asyncio)
+- smtpd (use aiosmtpd)
+
+Note: The `imp` and `distutils` modules were also removed in 3.12
+but are handled by dedicated recipes (imp_migrations.py and
+distutils_deprecations.py).
+
+See: https://docs.python.org/3/whatsnew/3.12.html#removed
+"""
+
+from typing import Any, 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, SearchResult
+from rewrite.python.visitor import PythonVisitor
+from rewrite.python.tree import MultiImport, Import
+from rewrite.java.tree import FieldAccess, Identifier
+from rewrite.utils import random_id
+
+# Define category path: Python > Migrate > Python 3.12
+_Python312 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.12"),
+]
+
+# Modules removed in Python 3.12 (excluding imp and distutils which have dedicated recipes)
+REMOVED_MODULES_312 = {
+    "asynchat": "Use `asyncio` instead.",
+    "asyncore": "Use `asyncio` instead.",
+    "smtpd": "Use `aiosmtpd` instead.",
+}
+
+
+def _mark_removed(tree: Any, module_name: str) -> Any:
+    """Add a SearchResult marker for a removed module."""
+    replacement = REMOVED_MODULES_312.get(module_name, "")
+    message = f"Module '{module_name}' was removed in Python 3.12. {replacement}"
+    search_marker = SearchResult(random_id(), 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)
+
+
+def _get_import_name(import_node: Any) -> Optional[str]:
+    """Extract the module name from an import node's qualid.
+
+    For a simple import like 'import asynchat', the qualid is a FieldAccess
+    where the name property is the identifier 'asynchat'.
+    """
+    qualid = import_node.qualid
+    if isinstance(qualid, FieldAccess):
+        return qualid.name.simple_name
+    if isinstance(qualid, Identifier):
+        return qualid.simple_name
+    return None
+
+
+@categorize(_Python312)
+class FindRemovedModules312(Recipe):
+    """
+    Find imports of modules that were removed in Python 3.12.
+
+    The following modules were removed in Python 3.12:
+    asynchat, asyncore, smtpd.
+
+    These modules were deprecated in earlier Python versions and have
+    been fully removed in Python 3.12. Code using these modules will
+    need to be updated to use alternative libraries.
+
+    Example:
+        Before:
+            import asynchat
+            from asyncore import dispatcher
+
+        After migration (manual):
+            # asynchat/asyncore - use asyncio instead
+            # smtpd - use aiosmtpd instead
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.FindRemovedModules312"
+
+    @property
+    def display_name(self) -> str:
+        return "Find modules removed in Python 3.12"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Find imports of modules that were removed in Python 3.12, "
+            "including asynchat, asyncore, and smtpd."
+        )
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_multi_import(
+                self, multi: MultiImport, p: ExecutionContext
+            ) -> Optional[MultiImport]:
+                multi = super().visit_multi_import(multi, p)
+
+                from_part = multi.from_
+                if from_part is not None:
+                    # Handle 'from X import ...' pattern
+                    if isinstance(from_part, Identifier):
+                        module_name = from_part.simple_name
+                        if module_name in REMOVED_MODULES_312:
+                            return _mark_removed(multi, module_name)
+                else:
+                    # Handle 'import X' pattern (no from clause)
+                    for import_node in multi.names:
+                        name = _get_import_name(import_node)
+                        if name in REMOVED_MODULES_312:
+                            return _mark_removed(multi, name)
+
+                return multi
+
+            def visit_import(
+                self, import_stmt: Import, p: ExecutionContext
+            ) -> Optional[Import]:
+                import_stmt = super().visit_import(import_stmt, p)
+                if self.cursor.first_enclosing(MultiImport) is not None:
+                    return import_stmt
+                name = _get_import_name(import_stmt)
+                if name in REMOVED_MODULES_312:
+                    return _mark_removed(import_stmt, name)
+                return import_stmt
+
+        return Visitor()