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

openrewrite_migrate_python/migrate/typing_union_to_pipe.py

@@ -0,0 +1,272 @@
+"""
+Recipes for migrating typing.Optional and typing.Union to PEP 604 union syntax.
+
+PEP 604 (Python 3.10+) introduced the `X | Y` syntax for union types:
+
+- typing.Optional[X] -> X | None
+- typing.Union[X, Y] -> X | Y
+- typing.Union[X, Y, Z] -> X | Y | Z
+
+See: https://peps.python.org/pep-0604/
+"""
+
+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
+from rewrite.python.visitor import PythonVisitor
+from rewrite.java.support_types import JRightPadded, Space
+from rewrite.java.tree import (
+    ArrayAccess,
+    Expression,
+    FieldAccess,
+    Identifier,
+    Literal,
+    ParameterizedType,
+)
+from rewrite.python.tree import CollectionLiteral, UnionType
+from rewrite.utils import random_id
+
+# Define category path: Python > Migrate > Python 3.10
+_Python310 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.10"),
+]
+
+
+def _is_typing_optional(clazz: Expression) -> bool:
+    """Check if a clazz expression is typing.Optional or just Optional."""
+    if isinstance(clazz, Identifier):
+        return clazz.simple_name == "Optional"
+    if isinstance(clazz, FieldAccess):
+        name = clazz.name
+        target = clazz.target
+        if (isinstance(name, Identifier) and name.simple_name == "Optional" and
+            isinstance(target, Identifier) and target.simple_name == "typing"):
+            return True
+    return False
+
+
+def _is_typing_union(clazz: Expression) -> bool:
+    """Check if a clazz expression is typing.Union or just Union."""
+    if isinstance(clazz, Identifier):
+        return clazz.simple_name == "Union"
+    if isinstance(clazz, FieldAccess):
+        name = clazz.name
+        target = clazz.target
+        if (isinstance(name, Identifier) and name.simple_name == "Union" and
+            isinstance(target, Identifier) and target.simple_name == "typing"):
+            return True
+    return False
+
+
+def _create_none_literal(prefix: Space) -> Literal:
+    """Create a Literal node representing None."""
+    return Literal(
+        _id=random_id(),
+        _prefix=prefix,
+        _markers=Markers.EMPTY,
+        _value=None,
+        _value_source="None",
+        _unicode_escapes=None,
+        _type=None,
+    )
+
+
+def _create_union_type(types: List[Expression], prefix: Space) -> UnionType:
+    """Create a UnionType node (X | Y | Z).
+
+    The UnionType node represents the PEP 604 union syntax.
+    Each type in the list is separated by ' | '.
+    """
+    # Create JRightPadded list with ' | ' after each type except the last
+    padded_types = []
+    for i, type_expr in enumerate(types):
+        # First type keeps its own prefix (or empty)
+        if i == 0:
+            type_expr = type_expr.replace(_prefix=Space.EMPTY) if hasattr(type_expr, 'replace') else type_expr
+        else:
+            # Other types get single space prefix (after the |)
+            type_expr = type_expr.replace(_prefix=Space.SINGLE_SPACE) if hasattr(type_expr, 'replace') else type_expr
+
+        # All types except the last get ' | ' after (space before |)
+        if i < len(types) - 1:
+            after = Space.SINGLE_SPACE  # Space before the |
+        else:
+            after = Space.EMPTY
+
+        padded_types.append(JRightPadded(
+            _element=type_expr,
+            _after=after,
+            _markers=Markers.EMPTY,
+        ))
+
+    return UnionType(
+        _id=random_id(),
+        _prefix=prefix,
+        _markers=Markers.EMPTY,
+        _types=padded_types,
+        _type=None,
+    )
+
+
+@categorize(_Python310)
+class ReplaceTypingOptionalWithUnion(Recipe):
+    """
+    Replace `typing.Optional[X]` with `X | None` (PEP 604).
+
+    PEP 604 introduced the `|` operator for union types in Python 3.10.
+    `Optional[X]` is equivalent to `X | None`.
+
+    Example:
+        Before:
+            from typing import Optional
+            name: Optional[str] = None
+
+        After:
+            name: str | None = None
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplaceTypingOptionalWithUnion"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `typing.Optional[X]` with `X | None`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "PEP 604 introduced the `|` operator for union types in Python 3.10. "
+            "Replace `Optional[X]` with the more concise `X | None` syntax."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.10", "typing", "pep604"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_parameterized_type(
+                self, param_type: ParameterizedType, p: ExecutionContext
+            ) -> Optional[Expression]:
+                param_type = super().visit_parameterized_type(param_type, p)
+
+                # Check if this is Optional[X]
+                if not _is_typing_optional(param_type.clazz):
+                    return param_type
+
+                # Get the type arguments
+                type_params = param_type.type_parameters
+                if type_params is None or len(type_params) != 1:
+                    return param_type
+
+                type_arg = type_params[0]
+
+                # Create X | None using UnionType
+                none_literal = _create_none_literal(Space.EMPTY)
+                return _create_union_type([type_arg, none_literal], param_type.prefix)
+
+            def visit_array_access(
+                self, array_access: ArrayAccess, p: ExecutionContext
+            ) -> Optional[Expression]:
+                array_access = super().visit_array_access(array_access, p)
+
+                # Check if this is Optional[X]
+                if not _is_typing_optional(array_access.indexed):
+                    return array_access
+
+                # Get the type argument from the dimension
+                index = array_access.dimension.index
+
+                # Create X | None using UnionType
+                none_literal = _create_none_literal(Space.EMPTY)
+                return _create_union_type([index, none_literal], array_access.prefix)
+
+        return Visitor()
+
+
+@categorize(_Python310)
+class ReplaceTypingUnionWithPipe(Recipe):
+    """
+    Replace `typing.Union[X, Y]` with `X | Y` (PEP 604).
+
+    PEP 604 introduced the `|` operator for union types in Python 3.10.
+    `Union[X, Y, Z]` becomes `X | Y | Z`.
+
+    Example:
+        Before:
+            from typing import Union
+            value: Union[int, str] = 0
+
+        After:
+            value: int | str = 0
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplaceTypingUnionWithPipe"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace `typing.Union[X, Y]` with `X | Y`"
+
+    @property
+    def description(self) -> str:
+        return (
+            "PEP 604 introduced the `|` operator for union types in Python 3.10. "
+            "Replace `Union[X, Y, ...]` with the more concise `X | Y | ...` syntax."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.10", "typing", "pep604"]
+
+    def editor(self) -> TreeVisitor[Any, ExecutionContext]:
+        class Visitor(PythonVisitor[ExecutionContext]):
+            def visit_parameterized_type(
+                self, param_type: ParameterizedType, p: ExecutionContext
+            ) -> Optional[Expression]:
+                param_type = super().visit_parameterized_type(param_type, p)
+
+                # Check if this is Union[X, Y, ...]
+                if not _is_typing_union(param_type.clazz):
+                    return param_type
+
+                # Get the type arguments
+                type_params = param_type.type_parameters
+                if type_params is None or len(type_params) < 2:
+                    return param_type
+
+                # Create union type with all type parameters
+                return _create_union_type(list(type_params), param_type.prefix)
+
+            def visit_array_access(
+                self, array_access: ArrayAccess, p: ExecutionContext
+            ) -> Optional[Expression]:
+                array_access = super().visit_array_access(array_access, p)
+
+                # Check if this is Union[X, Y, ...]
+                if not _is_typing_union(array_access.indexed):
+                    return array_access
+
+                # Get the type arguments from the dimension
+                index = array_access.dimension.index
+
+                # Extract elements from CollectionLiteral
+                if not isinstance(index, CollectionLiteral):
+                    return array_access
+
+                elements = list(index.elements)
+                if len(elements) < 2:
+                    return array_access
+
+                # Create union type with all elements
+                return _create_union_type(elements, array_access.prefix)
+
+        return Visitor()

openrewrite_migrate_python/migrate/unittest_deprecations.py

@@ -0,0 +1,140 @@
+"""
+Recipes for migrating deprecated unittest method aliases.
+
+Several unittest.TestCase method aliases were deprecated in Python 3.1-3.2
+and removed in Python 3.11/3.12:
+
+- assertEquals → assertEqual
+- assertNotEquals → assertNotEqual
+- assertAlmostEquals → assertAlmostEqual
+- assertNotAlmostEquals → assertNotAlmostEqual
+- assertRegexpMatches → assertRegex (deprecated 3.2, removed 3.12)
+- assertNotRegexpMatches → assertNotRegex (deprecated 3.2, removed 3.12)
+- assertRaisesRegexp → assertRaisesRegex (deprecated 3.2, removed 3.12)
+
+See: https://docs.python.org/3/library/unittest.html
+"""
+
+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.python.visitor import PythonVisitor
+from rewrite.java.tree import Identifier, MethodInvocation
+
+# Define category path: Python > Migrate > Python 3.11
+_Python311 = [
+    *Python,
+    CategoryDescriptor(display_name="Migrate"),
+    CategoryDescriptor(display_name="Python 3.11"),
+]
+
+# Mapping of deprecated method names to their replacements
+UNITTEST_ALIASES: Dict[str, str] = {
+    # Deprecated in 3.1, removed in 3.11
+    "assertEquals": "assertEqual",
+    "assertNotEquals": "assertNotEqual",
+    "assertAlmostEquals": "assertAlmostEqual",
+    "assertNotAlmostEquals": "assertNotAlmostEqual",
+    # Deprecated in 3.2, removed in 3.12
+    "assertRegexpMatches": "assertRegex",
+    "assertNotRegexpMatches": "assertNotRegex",
+    "assertRaisesRegexp": "assertRaisesRegex",
+    # Very old aliases (deprecated since 3.1)
+    "failUnlessEqual": "assertEqual",
+    "failIfEqual": "assertNotEqual",
+    "failUnless": "assertTrue",
+    "failIf": "assertFalse",
+    "failUnlessRaises": "assertRaises",
+    "failUnlessAlmostEqual": "assertAlmostEqual",
+    "failIfAlmostEqual": "assertNotAlmostEqual",
+}
+
+
+def _rename_method(method: MethodInvocation, new_name: str) -> MethodInvocation:
+    """Rename a method invocation."""
+    old_name = method.name
+    if not isinstance(old_name, Identifier):
+        return method
+
+    new_identifier = old_name.replace(_simple_name=new_name)
+    return method.replace(_name=new_identifier)
+
+
+def _is_self_method(method: MethodInvocation) -> bool:
+    """Check if this is a method call on self (typical for unittest)."""
+    select = method.select
+    if select is None:
+        return False
+    if isinstance(select, Identifier) and select.simple_name == "self":
+        return True
+    return False
+
+
+@categorize(_Python311)
+class ReplaceUnittestDeprecatedAliases(Recipe):
+    """
+    Replace deprecated unittest.TestCase method aliases with their modern equivalents.
+
+    Several unittest method aliases were deprecated and later removed:
+    - assertEquals → assertEqual
+    - assertNotEquals → assertNotEqual
+    - assertRegexpMatches → assertRegex
+    - And many more...
+
+    This recipe automatically renames these method calls to their non-deprecated versions.
+
+    Example:
+        Before:
+            class MyTest(unittest.TestCase):
+                def test_example(self):
+                    self.assertEquals(1, 1)
+                    self.assertRegexpMatches("hello", r"h.*o")
+
+        After:
+            class MyTest(unittest.TestCase):
+                def test_example(self):
+                    self.assertEqual(1, 1)
+                    self.assertRegex("hello", r"h.*o")
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.ReplaceUnittestDeprecatedAliases"
+
+    @property
+    def display_name(self) -> str:
+        return "Replace deprecated unittest method aliases"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Replace deprecated unittest.TestCase method aliases like `assertEquals` "
+            "with their modern equivalents like `assertEqual`. These aliases were "
+            "removed in Python 3.11/3.12."
+        )
+
+    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
+
+                method_name = method.name.simple_name
+
+                # Check if this is a deprecated unittest alias
+                if method_name in UNITTEST_ALIASES:
+                    # Only replace if called on self (typical unittest pattern)
+                    if _is_self_method(method):
+                        new_name = UNITTEST_ALIASES[method_name]
+                        return _rename_method(method, new_name)
+
+                return method
+
+        return Visitor()

openrewrite_migrate_python/migrate/upgrade_to_langchain02.py

@@ -0,0 +1,56 @@
+"""Composite recipe for upgrading to LangChain 0.2."""
+
+from typing import List
+
+from rewrite import Recipe
+from rewrite.category import CategoryDescriptor
+from rewrite.decorators import categorize
+from rewrite.marketplace import Python
+
+_Migrate = [*Python, CategoryDescriptor(display_name="Migrate")]
+
+
+@categorize(_Migrate)
+class UpgradeToLangChain02(Recipe):
+    """
+    Migrate to LangChain 0.2.
+
+    This composite recipe applies all necessary migrations for code using
+    LangChain 0.1 to be compatible with LangChain 0.2.
+
+    Key changes in LangChain 0.2:
+    - Third-party integrations moved from `langchain` to `langchain_community`
+    - Provider-specific classes should use dedicated packages (e.g. `langchain_openai`)
+
+    See: https://python.langchain.com/v0.2/docs/versions/v0_2/
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.langchain.UpgradeToLangChain02"
+
+    @property
+    def display_name(self) -> str:
+        return "Upgrade to LangChain 0.2"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Migrate to LangChain 0.2 by updating imports from `langchain` "
+            "to `langchain_community` and provider-specific packages."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "langchain", "0.2"]
+
+    def recipe_list(self) -> List[Recipe]:
+        from .langchain_community_imports import ReplaceLangchainCommunityImports
+        from .langchain_provider_imports import ReplaceLangchainProviderImports
+
+        return [
+            # First move langchain -> langchain_community
+            ReplaceLangchainCommunityImports(),
+            # Then move langchain_community -> provider packages where possible
+            ReplaceLangchainProviderImports(),
+        ]

openrewrite_migrate_python/migrate/upgrade_to_langchain1.py

@@ -0,0 +1,66 @@
+"""Composite recipe for upgrading to LangChain 1.0."""
+
+from typing import List
+
+from rewrite import Recipe
+from rewrite.category import CategoryDescriptor
+from rewrite.decorators import categorize
+from rewrite.marketplace import Python
+
+_Migrate = [*Python, CategoryDescriptor(display_name="Migrate")]
+
+
+@categorize(_Migrate)
+class UpgradeToLangChain1(Recipe):
+    """
+    Migrate to LangChain 1.0.
+
+    This composite recipe applies all necessary migrations for code using
+    earlier versions of LangChain to be compatible with LangChain 1.0.
+
+    Key changes in LangChain 1.0:
+    - Legacy chains, retrievers, and indexes moved to `langchain_classic`
+    - `create_react_agent` renamed to `create_agent`
+    - `initialize_agent`, `AgentExecutor`, `LLMChain` deprecated
+    - `hub` module moved to `langchain_classic`
+
+    See: https://docs.langchain.com/oss/python/migrate/langchain-v1
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.langchain.UpgradeToLangChain1"
+
+    @property
+    def display_name(self) -> str:
+        return "Upgrade to LangChain 1.0"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Migrate to LangChain 1.0 by applying all v0.2 migrations and "
+            "then moving legacy functionality to `langchain_classic`."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "langchain", "1.0"]
+
+    def recipe_list(self) -> List[Recipe]:
+        from .langchain_classic_imports import (
+            FindDeprecatedLangchainAgents,
+            ReplaceLangchainClassicImports,
+            FindLangchainCreateReactAgent,
+        )
+        from .upgrade_to_langchain02 import UpgradeToLangChain02
+
+        return [
+            # First apply all v0.2 migrations
+            UpgradeToLangChain02(),
+            # Move legacy modules to langchain_classic
+            ReplaceLangchainClassicImports(),
+            # Rename create_react_agent to create_agent
+            FindLangchainCreateReactAgent(),
+            # Flag deprecated agent patterns
+            FindDeprecatedLangchainAgents(),
+        ]

openrewrite_migrate_python/migrate/upgrade_to_python310.py

@@ -0,0 +1,91 @@
+"""Composite recipe for upgrading from Python 3.9 to Python 3.10."""
+
+from typing import List
+
+from rewrite import Recipe
+from rewrite.category import CategoryDescriptor
+from rewrite.decorators import categorize
+from rewrite.marketplace import Python
+
+# Define category path: Python > Migrate
+_Migrate = [*Python, CategoryDescriptor(display_name="Migrate")]
+
+
+@categorize(_Migrate)
+class UpgradeToPython310(Recipe):
+    """
+    Migrate deprecated APIs and adopt new syntax for Python 3.10 compatibility.
+
+    This composite recipe applies all necessary migrations for code
+    running on Python 3.9 to be compatible with Python 3.10.
+
+    Key changes in Python 3.10:
+    - PEP 604: Union types can be written as `X | Y` instead of `Union[X, Y]`
+    - `typing.Optional[X]` can be written as `X | None`
+    - `collections` ABCs removed from `collections` (use `collections.abc`)
+    - threading.currentThread() deprecated (use current_thread())
+    - threading.activeCount() deprecated (use active_count())
+
+    See: https://docs.python.org/3/whatsnew/3.10.html
+    """
+
+    @property
+    def name(self) -> str:
+        return "org.openrewrite.python.migrate.UpgradeToPython310"
+
+    @property
+    def display_name(self) -> str:
+        return "Upgrade to Python 3.10"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Migrate deprecated APIs and adopt new syntax for Python 3.10 compatibility. "
+            "This includes adopting PEP 604 union type syntax (`X | Y`) and other "
+            "modernizations between Python 3.9 and 3.10."
+        )
+
+    @property
+    def tags(self) -> List[str]:
+        return ["python", "migration", "3.10"]
+
+    def recipe_list(self) -> List[Recipe]:
+        """Return the list of recipes to apply for Python 3.10 upgrade."""
+        # Import here to avoid circular imports
+        from .collections_abc_migrations import ReplaceCollectionsAbcImports
+        from .threading_deprecations import (
+            ReplaceConditionNotifyAll,
+            ReplaceEventIsSet,
+            ReplaceThreadGetName,
+            ReplaceThreadIsDaemon,
+            ReplaceThreadSetDaemon,
+            ReplaceThreadSetName,
+            ReplaceThreadingActiveCount,
+            ReplaceThreadingCurrentThread,
+        )
+        from .typing_union_to_pipe import (
+            ReplaceTypingOptionalWithUnion,
+            ReplaceTypingUnionWithPipe,
+        )
+        from .upgrade_to_python39 import UpgradeToPython39
+
+        return [
+            # First apply all Python 3.9 upgrades (which includes 3.8)
+            UpgradeToPython39(),
+            # collections ABCs moved to collections.abc, removed in Python 3.10
+            ReplaceCollectionsAbcImports(),
+            # PEP 604: Replace typing.Optional[X] with X | None
+            ReplaceTypingOptionalWithUnion(),
+            # PEP 604: Replace typing.Union[X, Y] with X | Y
+            ReplaceTypingUnionWithPipe(),
+            # Threading camelCase deprecations (deprecated 3.10, removed 3.12)
+            ReplaceThreadingCurrentThread(),
+            ReplaceThreadingActiveCount(),
+            ReplaceConditionNotifyAll(),
+            ReplaceEventIsSet(),
+            # Threading getter/setter deprecations (auto-fix)
+            ReplaceThreadGetName(),
+            ReplaceThreadSetName(),
+            ReplaceThreadIsDaemon(),
+            ReplaceThreadSetDaemon(),
+        ]